### Docker Build and Run for Local Development

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/tests/kubestack-starter-kind/README.md

This example shows how to build a Docker image for Kubestack and then run it interactively, mounting the current directory as a volume. This enables local development and testing of infrastructure changes.

```shell
# Build the container image
docker build -t kubestack .

# Exec into the container image
# add docker socket mount for local dev
# -v /var/run/docker.sock:/var/run/docker.sock
docker run --rm -ti \
   -v `pwd`:/infra \
   kubestack
```

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

### Build Terraform Kustomize Provider

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/README.md

Compiles the Terraform provider plugin for Kustomize. This command builds the provider binary and places it in the appropriate directory for Terraform to use. Requires Go to be installed.

```makefile
make build
```

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

### Provision Kubernetes Manifests using Convenience Module

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/resources/resource.md

This example demonstrates provisioning Kubernetes manifests using the `custom-manifests` convenience module. It takes a configuration base key and a nested configuration object that specifies namespaces, resources, and common labels for the Kubernetes resources.

```hcl
module "example_custom_manifests" {
  source  = "kbst.xyz/catalog/custom-manifests/kustomization"
  version = "0.3.0"

  configuration_base_key = "default"  # must match workspace name
  configuration = {
    default = {
      namespace = "example-${terraform.workspace}"

      resources = [
        "${path.root}/manifests/example/namespace.yaml",
        "${path.root}/manifests/example/deployment.yaml",
        "${path.root}/manifests/example/service.yaml"
      ]

      common_labels = {
        "env" = terraform.workspace
      }
    }
  }
}
```

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

### kustomization_build Data Source Example Usage

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/build.md

This example demonstrates how to use the `kustomization_build` data source to build a Kustomization from a specified path and configure Kustomize options.

```hcl
data "kustomization_build" "test" {
  path = "test_kustomizations/basic/initial"
  kustomize_options {
    load_restrictor = "none"
    enable_helm = true
    helm_path = "/path/to/helm"
  }
}

```

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

### Define Kustomize Overlay with Resources and Options

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Illustrates the basic usage of the `kustomization_overlay` data source, including specifying `resources` to inherit from or include, and `kustomize_options` such as `load_restrictor`. This example demonstrates how to build a Kustomize overlay by referencing external files and applying Kustomize-specific configurations.

```hcl
locals {
  label_key = "example-label"
  label_value = true

  cm_key = "KEY1"
  cm_value = "VALUE1"
}

data "template_file" "example" {
  template = <<-EOT
    ---
    config:
      key1: value1
      key2: value2
    name: example
  EOT
}

data "kustomization_overlay" "example" {
  common_annotations = {
    example-annotation: true
  }

  common_labels = {
    (local.label_key) = local.label_value
  }

  config_map_generator {
    name = "example-configmap1"
    behavior = "create"
    literals = [
      "${local.cm_key}=${local.cm_value}",
      "filename.yaml=${data.template_file.example.rendered}"
    ]
  }

  resources = [
    "path/to/kustomization/to/inherit/from",
    "path/to/kubernetes/resource.yaml",
  ]
  kustomize_options {
    load_restrictor = "none"
  }
}
```

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

### Git Merge and Push to Main

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/tests/kubestack-starter-kind/README.md

This example shows the process of merging approved changes from a feature branch into the 'main' branch and pushing the update. This action applies the changes to the 'ops' environment and triggers a Terraform plan for the 'apps' environment.

```shell
# you can merge on the commandline
# or by merging a pull request
git checkout main
git merge examplechange
git push origin main
```

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

### Git Tagging for Production Deployment

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/tests/kubestack-starter-kind/README.md

This snippet demonstrates how to tag a specific commit on the 'main' branch with a prefix like 'apps-deploy-' to trigger the deployment pipeline for the 'apps' environment. It includes an example of creating a unique tag with a date and counter.

```shell
# make sure you're on the correct commit
git checkout main
git pull
git log -1

# if correct, tag the current commit
# any tag prefixed with `apps-deploy-`
# will trigger the pipeline
git tag apps-deploy-$(date -I)-0

# in case of multiple deploys on the same day,
# increase the counter
# e.g. git tag apps-deploy-2020-05-14-1
```

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

### Build Kubernetes Manifests from Kustomization Directory

Source: https://context7.com/kbst/terraform-provider-kustomization/llms.txt

Demonstrates using the `kustomization_build` data source to generate Kubernetes manifests from a specified Kustomize directory. It includes basic usage and an advanced example with `kustomize_options` for features like Helm chart inflation. The snippet also shows how to deploy these resources using `kustomization_resource` and access output values.

```hcl
# Basic usage: Build from a directory containing kustomization.yaml
data "kustomization_build" "example" {
  path = "./kubernetes/overlays/production"
}

# With kustomize options enabled
data "kustomization_build" "advanced" {
  path = "./kubernetes/base"

  kustomize_options {
    load_restrictor      = "LoadRestrictionsNone"  # Allow loading from outside path
    enable_alpha_plugins = false
    enable_exec          = false
    enable_helm          = true                     # Enable Helm chart inflation
    enable_star          = false
    helm_path            = "/usr/local/bin/helm"
  }
}

# Deploy all resources from the kustomization
resource "kustomization_resource" "example" {
  for_each = data.kustomization_build.example.ids

  manifest = data.kustomization_build.example.manifests[each.value]
  wait     = true  # Wait for resources to become ready
}

# Access outputs
output "resource_ids" {
  value = data.kustomization_build.example.ids
  # Returns: Set of resource IDs like ["apps/Deployment/default/nginx", "_/Service/default/nginx"]
}

output "resource_manifests" {
  value = data.kustomization_build.example.manifests
  # Returns: Map of resource ID to YAML manifest string
}

output "prioritized_ids" {
  value = data.kustomization_build.example.ids_prio
  # Returns: List of sets ordered by creation priority (e.g., namespaces before deployments)
}
```

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

### Provision Kubernetes Resources with Explicit Dependencies and Conditional Sensitivity

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/resources/resource.md

This example showcases provisioning Kubernetes resources using the `kustomization_resource` and `kustomization_build` data source. It illustrates explicit `depends_on` for ordered resource application and conditional `sensitive` attribute handling for Kubernetes secrets to prevent plan leakage.

```hcl
data "kustomization_build" "test" {
  path = "kustomize/test_kustomizations/basic/initial"
}

# first loop through resources in ids_prio[0]
resource "kustomization_resource" "p0" {
  for_each = data.kustomization_build.test.ids_prio[0]

  manifest = (
    contains(["_/Secret"], regex("(?P<group_kind>.*/.*)/.*/.*", each.value)["group_kind"])
    ? sensitive(data.kustomization_build.test.manifests[each.value])
    : data.kustomization_build.test.manifests[each.value]
  )
}

# then loop through resources in ids_prio[1]
# and set an explicit depends_on on kustomization_resource.p0
# wait 2 minutes for any deployment, statefulset or daemonset to become ready
resource "kustomization_resource" "p1" {
  for_each = data.kustomization_build.test.ids_prio[1]

  manifest = (
    contains(["_/Secret"], regex("(?P<group_kind>.*/.*)/.*/.*", each.value)["group_kind"])
    ? sensitive(data.kustomization_build.test.manifests[each.value])
    : data.kustomization_build.test.manifests[each.value]
  )
  wait = true
  timeouts {
    create = "2m"
    update = "2m"
  }

  depends_on = [kustomization_resource.p0]
}

# finally, loop through resources in ids_prio[2]

```

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

### Replace Secret Value with Kustomization Overlay

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

An example demonstrating how to use Kustomization overlays to replace a specific field value, such as an environment variable in a container, with data from a Kubernetes Secret.

```hcl
data "kustomization_overlay" "example" {
  resources = [
    "path/to/kustomization",
  ]

  replacements {
    source {
      kind = "Secret"
      name = "my-secret"
    }
    target {
      select {
        name = "hello"
        kind = "Job"
      }
      field_paths = [
        "spec.template.spec.containers.[name=hello].env.[name=SECRET_TOKEN].value"
    }
  }
}
```

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

### Attach to Running Terraform Provider Process for Debugging (Go, JSON, Shell)

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/README.md

Debug the kustomize Terraform provider by running it with delve and attaching your IDE. This involves starting the provider in debug mode with `dlv exec`, configuring your IDE (e.g., VS Code) to attach to the delve server, and setting the `TF_REATTACH_PROVIDERS` environment variable in your Terraform terminal.

```shell
PLUGIN_PROTOCOL_VERSIONS=5 dlv exec --api-version=2 --listen=127.0.0.1:49188 --headless /path/to/terraform-provider-kustomization/terraform-provider-kustomize -- --debug
```

```json
{
    "name": "Connect to server",
    "type": "go",
    "request": "attach",
    "mode": "remote",
    "remotePath": "${workspaceFolder}",
    "port": 49188,
    "host": "127.0.0.1",
    "apiVersion": 2,
    "env": {
        "KUBECONFIG_PATH": "${HOME}/.kube/config"
    },
    "dlvLoadConfig": {
        "followPointers": true,
        "maxVariableRecurse": 1,
        "maxStringLen": 512,
        "maxArrayValues": 64,
        "maxStructFields": -1
    }
}
```

```shell
export TF_REATTACH_PROVIDERS="{"registry.terraform.io/kbst/kustomization":{"Protocol":"grpc","Pid":13366,"Test":true,"Addr":{"Network":"unix","String":"/var/folders/7c/wdp684z11w1_6cj0d6lgl8hw0000gn/T/plugin2650218557"}}}"
```

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

### Basic Terraform Commands

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/tests/kubestack-starter-kind/README.md

This snippet includes essential Terraform commands, 'terraform init' to initialize the working directory and 'terraform plan' to generate an execution plan. These are fundamental steps for managing infrastructure with Terraform in Kubestack.

```shell
# run terraform init
terraform init

# run, e.g. terraform plan
terraform plan
```

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

### Git Checkout and Branching for Changes

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/tests/kubestack-starter-kind/README.md

This snippet demonstrates how to checkout a new branch from 'main' to begin making configuration changes in a Git repository, a crucial first step in the Kubestack GitOps process.

```shell
# checkout a new branch from main
git checkout -b examplechange main

# make your changes

# commit your changes
git commit  # write a meaningful commit message

# push your changes
git push origin examplechange
```

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

### Add Kustomize Components to Overlay

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Shows how to include Kustomize components in an overlay definition using the `components` argument within the `kustomization_overlay` data source. This allows inheriting configurations from separate Kustomize component directories.

```hcl
data "kustomization_overlay" "example" {
  components = [
    "path/to/component",
    "path/to/another/component"
  ]
}
```

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

### Configure Kustomize Overlay Labels

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Demonstrates how to set Kustomize `labels` using the `labels` block within the `kustomization_overlay` data source. It shows how to define key-value pairs for labels and optionally include them as selectors, using local variables for dynamic label values.

```hcl
# example shows how keys and values can be references
locals {
  label_key   = "example-label"
  label_value = true
}

data "kustomization_overlay" "example" {
  labels {
    pairs = {
      (local.label_key) = local.label_value
    }
    include_selectors = true # <-- false by default
  }
}
```

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

### Import Existing Kustomize Resources into Terraform

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/index.md

This command demonstrates how to import an existing Kubernetes resource managed by Kustomize into the Terraform state. The resource must have a `kubectl.kubernetes.io/last-applied-configuration` annotation.

```shell
terraform import 'kustomization_resource.test["apps/Deployment/test-namespace/test-deployment"]' apps/Deployment/test-namespace/test-deployment
```

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

### Deploy Application Resources using Kustomization Overlay

Source: https://context7.com/kbst/terraform-provider-kustomization/llms.txt

Deploys Kubernetes application resources based on a Kustomize overlay. It iterates over the IDs generated by the `kustomization_overlay` data source, applying manifests and optionally waiting for deployment completion based on the environment. It also specifies timeouts for resource operations and has a dependency on the namespace resource.

```terraform
resource "kustomization_resource" "app" {
  for_each = data.kustomization_overlay.app.ids

  manifest = data.kustomization_overlay.app.manifests[each.value]
  wait     = var.environment == "production" ? true : false

  timeouts {
    create = "10m"
    update = "10m"
    delete = "15m"
  }

  depends_on = [kustomization_resource.namespace]
}
```

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

### kustomization_overlay - Replacements

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Demonstrates how to use the `replacements` block to modify fields within resources, exemplified by replacing an environment variable value in a container.

```APIDOC
## kustomization_overlay - Replacements

### Description
Used to define replacements for fields within Kubernetes resources managed by Kustomize. This is analogous to Kustomize's `commonAnnotations`, `commonLabels`, `patchesJson6902`, `patchesStrategicMerge`, and `replacements` functionalities.

### Method
Not Applicable (Data Source Configuration)

### Endpoint
Not Applicable (Terraform Data Source)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

##### Options Attributes
When referencing a field path, or field paths, `options` can be used to access a sub-component of the path.

- `delimiter` (string) - Optional - Used to split a field.
- `index` (number) - Optional - Used to choose which portion of the split to take (default 0).
- `create` (bool) - Optional - Whether to add a target field if it is missing.

### Request Example
```hcl
data "kustomization_overlay" "example" {
  resources = [
    "path/to/kustomization",
  ]

  replacements {
    source {
      kind = "Secret"
      name = "my-secret"
    }
    target {
      select {
        name = "hello"
        kind = "Job"
      }
      field_paths = [
        "spec.template.spec.containers.[name=hello].env.[name=SECRET_TOKEN].value"
      ]
    }
  }
}
```

### Response
#### Success Response (200)
This is a Terraform data source, it does not produce a direct HTTP response. The configuration is used by Terraform to manage Kustomize resources.

#### Response Example
```json
{
  "message": "Configuration applied successfully"
}
```
```

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

### Git Commit and Push for Review Updates

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/tests/kubestack-starter-kind/README.md

This code block illustrates how to commit and push subsequent changes made to a branch after a review, ensuring that feedback is incorporated into the proposed updates before merging.

```shell
# make sure you're in the correct branch
git checkout examplechange

# make changes required by the review

# commit and push the required changes
git commit  # write a meaningful commit message
git push origin examplechange
```

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

### Launch Specific Terraform Provider Test Function for Debugging (Go, JSON)

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/README.md

Debug a specific test function within the kustomize Terraform provider by configuring your IDE (e.g., VS Code) to launch the test in debug mode. This involves setting up a `launch.json` configuration with the `request` type as `launch` and `mode` as `test`, specifying the program, environment variables, and test arguments.

```json
{
    "name": "Launch test function",
    "type": "go",
    "request": "launch",
    "mode": "test",
    "program": "${workspaceFolder}/kustomize",
    "env": {
        "TF_ACC": "1",
        "KUBECONFIG_PATH": "${env:HOME}/.kube/config"
    },
    "args": [
        "-test.v",
        "-test.run",
        "^TestFunctionNameGoesHere$"
    ],
}
```

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

### Configure Kustomize Overlay with ConfigMap Generator

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Shows how to define and configure a Kustomize `configMapGenerator` within a `kustomization_overlay` data source. It illustrates setting literals, referencing rendered templates from a `template_file` data source, and applying generator options like disabling name suffix hashing. This allows for dynamic generation of ConfigMaps based on Terraform inputs.

```hcl
locals {
  cm_key   = "KEY1"
  cm_value = "VALUE1"
}

data "template_file" "example" {
  template = <<-"EOT"
    ---
    config:
      key1: value1
      key2: value2
    name: example
  EOT
}

data "kustomization_overlay" "example" {
  # a first ConfigMap
  config_map_generator {
    name     = "example-configmap1"
    behavior = "create"
    literals = [
      "${local.cm_key}=${local.cm_value}",
      "filename.yaml=${data.template_file.example.rendered}"
    ]

    options {
      disable_name_suffix_hash = true
    }
  }

  # a second ConfigMap
  config_map_generator {
    name = "example-configmap2"
    literals = [
      "KEY1=VALUE1",
      "KEY2=VALUE2"
    ]
    envs = [
      "path/to/properties.env"
    ]
    files = [
      "path/to/config/file.cfg"
    ]
  }
}
```

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

### Cloud Provider Authentication Commands

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/tests/kubestack-starter-kind/README.md

This section provides the necessary commands to authenticate with major cloud providers (AWS, Azure, GCP) within the Kubestack container environment. These commands ensure that Terraform and cloud CLIs can access and manage resources.

```shell
# for AWS
aws configure

# for Azure
az login

# for GCP
gcloud init
gcloud auth application-default login
```

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

### Define Kustomize Overlay with Common Annotations and Labels

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Demonstrates how to configure common annotations and labels for a Kustomize overlay using the `kustomization_overlay` data source. This is useful for applying consistent metadata across generated Kubernetes resources. It uses local variables for dynamic label values.

```hcl
locals {
  label_key   = "example-label"
  label_value = true
}

data "kustomization_overlay" "example" {
  common_annotations = {
    example-annotation = true
  }

  common_labels = {
    (local.label_key) = local.label_value
  }
}
```

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

### Configure Helm Globals for Kustomize Overlay (HCL)

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Sets global configurations for Helm within a Kustomize overlay, such as `chart_home` and `config_home` directories. This requires enabling Helm support via `kustomize_options.enable_helm`. It works in conjunction with `helm_charts` to manage chart inflation and Kustomize's Helm-related directories.

```hcl
data "kustomization_overlay" "minecraft" {
  helm_globals {
    chart_home = "/local/chart/path/"
  }

  helm_charts {
    # this is relative to `chart_home` (eg: ${chart_home}/charts/${name})
    name = "minecraft"
    version = "3.1.3"
    release_name = "moria"
    values_inline = <<VALUES
      minecraftServer:
        eula: true
        difficulty: hard
        rcon:
          enabled: true
    VALUES
  }

  kustomize_options = {
    enable_helm = true
    helm_path = "helm"
  }
}
```

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

### Test Terraform Kustomize Provider

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/README.md

Runs the acceptance tests for the Terraform Kustomize provider. This requires setting the KUBECONFIG_PATH environment variable to a valid Kubernetes configuration file. It is recommended to use Kind or Minikube for testing.

```makefile
make test
```

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

### Terraform Workspace Selection

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/tests/kubestack-starter-kind/README.md

These commands demonstrate how to select the desired Terraform workspace, either 'ops' or 'apps', within the Kubestack environment. This is essential for targeting the correct infrastructure environment for Terraform operations.

```shell
# for ops
terraform workspace select ops

# or for apps
terraform workspace select apps
```

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

### Configure Kustomize Options for Overlay (HCL)

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Sets various options for Kustomize processing within an overlay. This includes controlling load restrictions, enabling Helm chart support, and specifying the Helm binary path. It's an optional configuration.

```hcl
data "kustomization_overlay" "example" {
  kustomize_options {
    load_restrictor = "none"
    enable_helm = true
    helm_path = "/path/to/helm"
  }
}
```

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

### Build Kustomization Overlay with Environment-Specific Configuration

Source: https://context7.com/kbst/terraform-provider-kustomization/llms.txt

Defines a Kustomize overlay for an application, applying environment-specific configurations for labels, image tags, replica counts, config maps, and resource patches. This data source prepares the Kubernetes manifests based on input variables for different environments.

```terraform
data "kustomization_overlay" "app" {
  namespace   = "${var.environment}-app"
  name_prefix = "${var.environment}-"

  resources = ["./kubernetes/base"]

  common_labels = {
    environment = var.environment
    managed-by  = "terraform"
  }

  images {
    name    = "myapp"
    new_tag = var.app_version
  }

  replicas {
    name  = "app-deployment"
    count = var.replica_count
  }

  config_map_generator {
    name     = "app-config"
    behavior = "merge"

    literals = [
      "ENVIRONMENT=${var.environment}",
      "LOG_LEVEL=${var.environment == "production" ? "warn" : "debug"}"
    ]
  }

  patches {
    target {
      kind = "Deployment"
      name = "app-deployment"
    }

    patch = var.environment == "production" ? <<-EOF
      - op: add
        path: /spec/template/spec/containers/0/resources
        value:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1000m"
    EOF : <<-EOF
      - op: add
        path: /spec/template/spec/containers/0/resources
        value:
          requests:
            memory: "256Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "250m"
    EOF
  }
}
```

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

### Configure Kustomization Provider and Variables

Source: https://context7.com/kbst/terraform-provider-kustomization/llms.txt

This HCL code block sets up the Terraform provider for Kustomization, specifying the source and version. It also defines essential variables for environment, kubeconfig path, cluster context, application version, and replica count, enabling parameterized deployments.

```hcl
# Provider configuration
terraform {
  required_providers {
    kustomization = {
      source  = "kbst/kustomization"
      version = "0.9.0"
    }
  }
}

provider "kustomization" {
  kubeconfig_path = var.kubeconfig_path
  context         = var.cluster_context
}

# Variables
variable "environment" {
  type    = string
  default = "staging"
}

variable "kubeconfig_path" {
  type    = string
  default = "~/.kube/config"
}

variable "cluster_context" {
  type = string
}

variable "app_version" {
  type = string
}

variable "replica_count" {
  type    = number
  default = 2
}

```

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

### Configure Helm Charts in Kustomize Overlay (HCL)

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Defines Helm chart configurations within a Kustomize overlay. This includes chart name, version, repository, release name, namespace, CRD inclusion, test skipping, and values for templating. It also allows specifying API versions and Kubernetes versions for templating.

```hcl
data "kustomization_overlay" "minecraft" {
  helm_charts {
    name = "minecraft"
    version = "3.1.3"
    repo = "https://itzg.github.io/minecraft-server-charts"
    release_name = "moria"
    include_crds = false
    skip_tests = false
    kube_version = "1.29.0"
    api_versions = ["monitoring.coreos.com/v1"]
    values_inline = <<VALUES
      minecraftServer:
        eula: true
        difficulty: hard
        rcon:
          enabled: true
    VALUES
  }

  kustomize_options = {
    enable_helm = true
    helm_path = "helm"
  }
}
```

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

### kustomization_overlay - Resources

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Specifies a list of Kustomization resources to inherit from or include.

```APIDOC
## kustomization_overlay - Resources

### Description
List of [Kustomization resources](https://kubectl.docs.kubernetes.io/references/kustomize/kustomization/resource/) to inherit from or include.

### Method
Not Applicable (Data Source Configuration)

### Endpoint
Not Applicable (Terraform Data Source)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```hcl
data "kustomization_overlay" "example" {
  resources = [
    "path/to/kustomization/to/inherit/from",
    "path/to/kubernetes/resource.yaml",
  ]
}
```

### Response
#### Success Response (200)
This is a Terraform data source, it does not produce a direct HTTP response. The configuration is used by Terraform to manage Kustomize resources.

#### Response Example
```json
{
  "message": "Configuration applied successfully"
}
```
```

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

### Define Kustomize Vars for Substitution

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Sets up Kustomize variables for name reference substitution. This is commonly used to reference generated resource names, including their hash suffixes.

```hcl
data "kustomization_overlay" "example" {
  resources = [
    "path/to/kustomization",
  ]

  secret_generator {
    name = "example-secret1"
    type = "Opaque"
    literals = [
      "password=${random_password.password.result}",
    ]
  }

  vars {
    name = "SECRET_NAME"
    obj_ref {
      api_version = "v1"
      kind = "Secret"
      name = "example-secret1"
    }
    field_ref {
      field_path = "metadata.name"
    }
  }

  patches {
    patch = <<-EOF
      - op: add
        path: /spec/template/spec/containers/0/env
        value: [{"name": "SECRET_NAME", "value": "$(SECRET_NAME)"}]
    EOF
    target {
      group = "apps"
      version = "v1"
      kind = "Deployment"
      name = "example"
    }
  }
}
```

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

### Deploy Kubernetes Resources with kustomization_resource

Source: https://context7.com/kbst/terraform-provider-kustomization/llms.txt

The `kustomization_resource` resource allows managing individual Kubernetes manifests directly within Terraform. It supports basic deployments, resources with readiness waits, and deployment based on Kustomize build outputs. Dependencies can be explicitly defined using `depends_on`.

```hcl
# Basic resource deployment
resource "kustomization_resource" "namespace" {
  manifest = <<-EOF
    apiVersion: v1
    kind: Namespace
    metadata:
      name: my-application
      labels:
        environment: production
  EOF
}

# Resource with wait condition for readiness
resource "kustomization_resource" "deployment" {
  manifest = <<-EOF
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx
      namespace: my-application
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: nginx
      template:
        metadata:
          labels:
            app: nginx
        spec:
          containers:
          - name: nginx
            image: nginx:1.21
            ports:
            - containerPort: 80
  EOF

  wait = true  # Wait for deployment to become ready

  timeouts {
    create = "5m"
    update = "5m"
    delete = "10m"
  }

  depends_on = [kustomization_resource.namespace]
}

# Deploy from kustomization_build data source
data "kustomization_build" "app" {
  path = "./k8s/overlays/prod"
}

resource "kustomization_resource" "app" {
  for_each = data.kustomization_build.app.ids

  manifest = data.kustomization_build.app.manifests[each.value]
  wait     = true
}

# Deploy with prioritized ordering (respects dependency order)
locals {
  manifests = data.kustomization_build.app.manifests
}

# Deploy in priority order (e.g., namespaces before deployments)
resource "kustomization_resource" "prio1" {
  for_each = data.kustomization_build.app.ids_prio[0]

  manifest = local.manifests[each.value]
}

resource "kustomization_resource" "prio2" {
  for_each = data.kustomization_build.app.ids_prio[1]

  manifest = local.manifests[each.value]

  depends_on = [kustomization_resource.prio1]
}

resource "kustomization_resource" "prio3" {
  for_each = data.kustomization_build.app.ids_prio[2]

  manifest = local.manifests[each.value]

  depends_on = [kustomization_resource.prio2]
}

# Import existing resource with last-applied-configuration annotation
# terraform import 'kustomization_resource.existing["apps/Deployment/default/nginx"]' apps/Deployment/default/nginx
resource "kustomization_resource" "existing" {
  manifest = file("./existing-deployment.yaml")
}

# Output resource UID
output "deployment_uid" {
  value = kustomization_resource.deployment.id
  # Returns: Kubernetes UID like "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
}

```

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

### Configure Kustomization Overlay Resources

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Defines the resources to be included or inherited by a Kustomization overlay. This can be a path to another Kustomization directory or a Kubernetes resource file.

```hcl
data "kustomization_overlay" "example" {
  resources = [
    "path/to/kustomization/to/inherit/from",
    "path/to/kubernetes/resource.yaml",
  ]
}
```

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

### kustomization_overlay - Vars

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Defines Kustomize vars for substituting name references.

```APIDOC
## kustomization_overlay - Vars

### Description
Define [Kustomize vars](https://kubectl.docs.kubernetes.io/references/kustomize/kustomization/vars/) to substitute name references. E.g. the name of a generated secret including its hash suffix.

### Method
Not Applicable (Data Source Configuration)

### Endpoint
Not Applicable (Terraform Data Source)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

#### Child Attributes

- `name` (string) - Required - Name of the var.
- `obj_ref` (block) - Required - Reference to the Kubernetes resource as specified by `api_version`, `kind` and `name`.
  - `api_version` (string) - Required - The API version of the resource.
  - `kind` (string) - Required - The kind of the resource.
  - `name` (string) - Required - The name of the resource.
- `field_ref` (block) - Required - Reference to the attribute of the Kubernetes resource specified by `field_path`.
  - `field_path` (string) - Required - The path to the field within the resource.

### Request Example
```hcl
data "kustomization_overlay" "example" {
  resources = [
    "path/to/kustomization",
  ]

  secret_generator {
    name = "example-secret1"
    type = "Opaque"
    literals = [
      "password=${random_password.password.result}",
    ]
  }

  vars {
    name = "SECRET_NAME"
    obj_ref {
      api_version = "v1"
      kind = "Secret"
      name = "example-secret1"
    }
    field_ref {
      field_path = "metadata.name"
    }
  }

  patches {
    patch = <<-"EOF"
      - op: add
        path: /spec/template/spec/containers/0/env
        value: [{"name": "SECRET_NAME", "value": "$(SECRET_NAME)"}]
    EOF
    target {
      group = "apps"
      version = "v1"
      kind = "Deployment"
      name = "example"
    }
  }
}
```

### Response
#### Success Response (200)
This is a Terraform data source, it does not produce a direct HTTP response. The configuration is used by Terraform to manage Kustomize resources.

#### Response Example
```json
{
  "message": "Configuration applied successfully"
}
```
```

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

### kustomization_overlay - Helm Charts

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Defines Kustomize Helm charts to be included in the overlay.

```APIDOC
## kustomization_overlay - Helm Charts

### Description
Define [Kustomize helmCharts](https://github.com/kubernetes-sigs/kustomize/blob/master/examples/chart.md).

Must enable helm support via [kustomize_options](#kustomize_options---optional) `enable_helm`.

### Method
Not Applicable (Data Source Configuration)

### Endpoint
Not Applicable (Terraform Data Source)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```hcl
data "kustomization_overlay" "example" {
  # Assuming kustomize_options block with enable_helm = true is configured elsewhere or implicitly enabled
  # helm_charts {
  #   release_name = "my-release"
  #   chart = "./charts/mychart"
  #   version = "1.2.3"
  #   values = {
  #     replicaCount = 2
  #   }
  # }
}
```

### Response
#### Success Response (200)
This is a Terraform data source, it does not produce a direct HTTP response. The configuration is used by Terraform to manage Kustomize resources.

#### Response Example
```json
{
  "message": "Configuration applied successfully"
}
```
```

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

### kustomization_overlay - Transformers

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Specifies a list of paths to Kustomize transformers.

```APIDOC
## kustomization_overlay - Transformers

### Description
List of paths to Kustomize transformers.

### Method
Not Applicable (Data Source Configuration)

### Endpoint
Not Applicable (Terraform Data Source)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```hcl
data "kustomization_overlay" "example" {
  transformers = [
    "path/to/kustomization/transformer.yaml"
  ]
}
```

### Response
#### Success Response (200)
This is a Terraform data source, it does not produce a direct HTTP response. The configuration is used by Terraform to manage Kustomize resources.

#### Response Example
```json
{
  "message": "Configuration applied successfully"
}
```
```

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

### Configure Kustomize Provider with Kubernetes Credentials

Source: https://context7.com/kbst/terraform-provider-kustomization/llms.txt

This snippet shows how to configure the Kustomize Terraform provider using different methods for Kubernetes cluster access. It covers using a kubeconfig file path, raw kubeconfig content, and in-cluster configuration. It also includes an option to disable gzip compression for `lastAppliedConfig` annotations.

```hcl
terraform {
  required_providers {
    kustomization = {
      source  = "kbst/kustomization"
      version = "0.9.0"
    }
  }
}

# Option 1: Using kubeconfig file path
provider "kustomization" {
  kubeconfig_path = "~/.kube/config"
  context         = "production-cluster"  # Optional: for multi-context kubeconfig
}

# Option 2: Using raw kubeconfig content
provider "kustomization" {
  kubeconfig_raw = yamlencode({
    apiVersion = "v1"
    kind       = "Config"
    clusters = [{
      name = "my-cluster"
      cluster = {
        server                     = "https://kubernetes.example.com"
        certificate-authority-data = base64encode(file("ca.crt"))
      }
    }]
    users = [{
      name = "my-user"
      user = {
        client-certificate-data = base64encode(file("client.crt")),
        client-key-data         = base64encode(file("client.key"))
      }
    }]
    contexts = [{
      name = "my-context"
      context = {
        cluster = "my-cluster"
        user    = "my-user"
      }
    }]
    current-context = "my-context"
  })
}

# Option 3: Using in-cluster configuration (for pods running inside Kubernetes)
provider "kustomization" {
  kubeconfig_incluster = true
}

# Optional: Disable gzip compression for lastAppliedConfig annotations
provider "kustomization" {
  kubeconfig_path          = "~/.kube/config"
  gzip_last_applied_config = false  # Defaults to true
}
```

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

### kustomization_overlay - Replicas

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Configures the number of replicas for specified Kubernetes resources using the `replicas` block.

```APIDOC
## kustomization_overlay - Replicas

### Description
Sets the [Kustomize replicas](https://kubectl.docs.kubernetes.io/references/kustomize/kustomization/replicas/) to change the number of replicas of a resource.

### Method
Not Applicable (Data Source Configuration)

### Endpoint
Not Applicable (Terraform Data Source)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

#### Child attributes

- `name` (string) - Required - Name of the Kubernetes resource to change replicas of.
- `count` (number) - Required - Number of desired replicas.

### Request Example
```hcl
data "kustomization_overlay" "example" {
  replicas {
    name = "example-deployment"
    count = 3
  }

  replicas {
    name = "example-statefulset"
    count = 5
  }
}
```

### Response
#### Success Response (200)
This is a Terraform data source, it does not produce a direct HTTP response. The configuration is used by Terraform to manage Kustomize resources.

#### Response Example
```json
{
  "message": "Configuration applied successfully"
}
```
```

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

### Migrate Kustomize Resource IDs in Terraform State

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/index.md

This Python script and accompanying shell commands are used to migrate resource IDs in the Terraform state from a legacy format to a new format that supports API version upgrades. The new format is `group/Kind/namespace/name`.

```python
import sys
import re

for si in sys.stdin.readlines():

    if not "kustomization_resource" in si:
        continue

    so = re.sub(r"(.*)\[\"([^_]*)\_[^_]*\_([^|]*)\|([^|]*)\|([^\"]*)\"]",
                r'\1["\2/\3/\4/\5"]', si)

    so = re.sub(r"\~[GX]", r"_", so)

    print(f"terraform state mv '{si.strip()}' '{so.strip()}'")
```

```shell
cat > migrate.py <<'EOF'
import sys
import re

for si in sys.stdin.readlines():

    if not "kustomization_resource" in si:
        continue

    so = re.sub(r"(.*)\[\"([^_]*)\_[^_]*\_([^|]*)\|([^|]*)\|([^\"]*)\"]",
                r'\1["\2/\3/\4/\5"]', si)

    so = re.sub(r"\~[GX]", r"_", so)

    print(f"terraform state mv '{si.strip()}' '{so.strip()}'")

EOF

terraform state list | python3 migrate.py > state_mv.sh

bash state_mv.sh
```

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

### Configure Generator Options for Kustomize Overlay (HCL)

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Sets options for all generators within a Kustomize overlay. This includes adding labels, annotations, and controlling hash suffix generation. It's an optional configuration block.

```hcl
data "kustomization_overlay" "example" {
  generator_options {
    labels = {
      example-label = "example"
    }

    annotations = {
      example-annotation = "example"
    }

    disable_name_suffix_hash = true
  }
}
```

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

### Apply Kustomize Transformers

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Specifies paths to Kustomization transformer files, allowing for modification of Kubernetes resources as part of the Kustomize build process.

```hcl
data "kustomization_overlay" "example" {
  transformers = [
    "path/to/kustomization/transformer.yaml"
  ]
}
```

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

### Configure Kustomize Replacements for Overlay (HCL)

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Defines Kustomize replacements to modify Kubernetes resources. Replacements can be specified via a file path or by defining source and target selectors, including field paths. This is an optional configuration block.

```hcl
# Example with path to replacements file:
data "kustomization_overlay" "example_path" {
  replacements {
    path = "path/to/replacements.yaml"
  }
}

# Example with source and target selectors:
data "kustomization_overlay" "example_selectors" {
  replacements {
    source {
      kind = "Deployment"
      name = "my-app"
      field_path = "metadata.labels.version"
    }
    target {
      select {
        kind = "Service"
        name = "my-app-service"
      }
      field_paths = ["spec.selector.version"]
    }
  }
}
```

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

### Set Kustomize Replicas for Resources

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Allows setting the number of replicas for specified Kubernetes resources. This is useful for managing the scaling of deployments, statefulsets, etc.

```hcl
data "kustomization_overlay" "example" {
  replicas {
    name = "example-deployment"
    count = 3
  }

  replicas {
    name = "example-statefulset"
    count = 5
  }
}
```

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

### Output Deployed Resource IDs and Namespace

Source: https://context7.com/kbst/terraform-provider-kustomization/llms.txt

Defines Terraform outputs for the deployed Kubernetes resource IDs and the created namespace. These outputs provide visibility into the applied resources and the target namespace name after the Terraform apply.

```terraform
output "deployed_resources" {
  value = data.kustomization_overlay.app.ids
}

output "namespace" {
  value = "${var.environment}-app"
}
```

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

### Configure Kustomize Patches for Overlay (HCL)

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/data-sources/overlay.md

Defines Kustomize patches to modify Kubernetes resources. Patches can be specified by path or as inline strings, with options to target specific resources and control name/kind changes. This is an optional configuration block.

```hcl
data "kustomization_overlay" "example" {
  resources = [
    "path/to/kustomization",
  ]

  patches {
    path = "path/to/patch.yaml"
    target {
      label_selector = "app=example,env=${terraform.workspace}"
    }
  }

  patches {
    target {
      kind = "Namespace"
      name = "test-ns"
    }
    patch = <<-EOF
      kind: Namespace
      metadata:
        name: new-ns
    EOF
    options {
      allow_name_change = true
    }
  }

  patches {
    patch = <<-EOF
      - op: replace
        path: /spec/rules/0/http/paths/0/path
        value: /newpath
    EOF
    target {
      group = "networking.k8s.io"
      version = "v1beta1"
      kind = "Ingress"
      name = "example"
      namespace = "example-basic"
      annotation_selector = "nginx.ingress.kubernetes.io/rewrite-target"
    }
  }
}
```

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

### Configure Kustomize Terraform Provider

Source: https://github.com/kbst/terraform-provider-kustomization/blob/master/docs/index.md

This block configures the Kustomize provider, specifying the source and version. It also sets up authentication by defining one of `kubeconfig_path`, `kubeconfig_raw`, or `kubeconfig_incluster`.

```hcl
terraform {
  required_providers {
    kustomization = {
      source  = "kbst/kustomization"
      version = "0.9.0"
    }
  }
}

provider "kustomization" {
  # one of kubeconfig_path, kubeconfig_raw or kubeconfig_incluster must be set

  # kubeconfig_path = "~/.kube/config"
  # can also be set using KUBECONFIG_PATH environment variable

  # kubeconfig_raw = data.template_file.kubeconfig.rendered
  # kubeconfig_raw = yamlencode(local.kubeconfig)

  # kubeconfig_incluster = true
}
```