Repository files navigation

A Go-based tool for dynamically generating Terraform modules, includingmain.tf,variables.tf, andversions.tf, by leveraging Terraform schemas and user-defined resource configurations.

• Parses and validates Terraform providers and resources.
• Dynamically generatesmain.tf,variables.tf, andversions.tf files.
• Supports filtering Terraform provider schemas for required resources.
• Removes computed and invalid attributes from schemas.
• Ensures proper HCL formatting usingterraform fmt.
• Logs detailed messages at various levels (info, debug, warn, error).

• Terraform binary installed (v1.3+)

• Go 1.23+
• go.mod dependencies (e.g.,terraform-json,terraform-exec,zclconf/go-cty).

# Add the pluginasdf plugin add tmcg https://github.com/kbcz1989/asdf-tmcg.git# Install a versionasdf install tmcg latest# Set it globallyasdf global tmcg latest# Verify installationtmcg --version

ARCH=$(uname -m| grep -q'aarch64'&&echo'arm64'||echo'amd64')sudo wget"https://github.com/kbcz1989/tmcg/releases/latest/download/tmcg-linux-$ARCH" -O /usr/local/bin/tmcgsudo chmod +x /usr/local/bin/tmcg

ARCH=$(uname -m| grep -q'arm64'&&echo'arm64'||echo'amd64')curl -L"https://github.com/kbcz1989/tmcg/releases/latest/download/tmcg-darwin-$ARCH" -o /usr/local/bin/tmcgchmod +x /usr/local/bin/tmcg

$ARCH =if ($ENV:PROCESSOR_ARCHITECTURE -eq"ARM64") {"arm64" }else {"amd64" }Invoke-WebRequest -Uri"https://github.com/kbcz1989/tmcg/releases/latest/download/tmcg-windows-$ARCH.exe" -OutFile"$Env:LOCALAPPDATA\tmcg.exe" -UseBasicParsing

Clone the repository:

git clone https://github.com/kbcz1989/tmcg.gitcd tmcg-generator

Build the project:

go build -o tmcg

Run the binary:

./tmcg --help

./tmcg -p hashicorp/aws:>=3.0 -r aws_instance:single -d ./output -l debug

• main.tf: Contains resource definitions with dynamic blocks.
• variables.tf: Defines input variables for the resources.
• versions.tf: Specifies required providers and their versions.

Run all tests:

maketest

• Verifies resource and provider parsing.
• Ensuresmain.tf,variables.tf, andversions.tf generation matches expectations.
• Validates cleanup of HCL files and schema handling.

1. Parsing Provider and Resource Arguments

   • The tool takes arguments for providers and resources passed via CLI flags.
   • Providers can be specified with optional versions (e.g.,hashicorp/aws:>=3.0).
   • Resources are parsed with an optional mode (single ormultiple), defaulting tomultiple.

2. Buildingversions.tf

   • The tool constructs aversions.tf file based on the provided provider arguments.
   • The file specifies provider sources and version constraints.

3. Runningterraform init

   • Once theversions.tf file is created,tmcg runsterraform init to download required providers.
   • This ensures that all dependencies are in place before schema processing.

4. Fetching Terraform Provider Schema

   • The tool fetches the full schema for the specified providers usingterraform providers schema.
   • This includes details of attributes, blocks, and their metadata (e.g., required, computed, optional).

5. Filtering the Schema for Parsed Resources

   • From the fetched schema, only the resources specified via CLI arguments are retained.
   • This narrows down the schema to the required subset.

6. Removing Computed-Only Attributes

   • The filtered schema is further refined by removing attributes that are only computed and cannot be configured by users.

7. Generatingmain.tf andvariables.tf

   • Based on the filtered schema,tmcg generates:
     • main.tf: A skeleton configuration for resources with all possible attributes.
     • variables.tf: A file specifying the input variable types for Terraform.

8. Runningterraform validate

   • After generating the configuration files,tmcg runsterraform validate to check for errors or warnings.
   • This step helps identify any invalid or unsupported attributes.

9. Removing Invalid Attributes

   • If validation errors are detected,tmcg analyzes the errors and removes invalid attributes from the filtered schema.
   • The process ensures the configuration adheres to the schema and Terraform constraints.

10. Re-running Generation

    • With the refined schema,tmcg regeneratesmain.tf andvariables.tf.
    • This ensures the configurations are correct after invalid attributes are removed.

11. Runningterraform fmt

    • The tool formats the generated Terraform configuration files for better readability and consistency.

12. Final Validation

    • A finalterraform validate is executed to confirm the validity of the configurations.

Imagine you are tasked with writing a Terraform module for deploying resources, such as AWS instances or Azure resources. Crafting such modules can be a daunting task because:

1. You need to understand the resource schema in-depth or read docs line by line: Terraform provider resources often support dozens of attributes, some required, others optional, and many computed.
2. Ensuring flexibility: To make a module reusable, you must expose configurable parameters for all relevant resource attributes.
3. Keeping up with upstream changes: Terraform providers are frequently updated, and your module must remain compatible with the latest schema.

This is wheretmcg can be helpful.

tmcg generates Terraform module boilerplate code by leveraging Terraform provider schemas directly. Its approach is guided by the author's subjective best practices, emphasizing flexibility and extensibility:

• Comprehensive attribute support: All attributes supported by the upstream provider are included in the generated code, ensuring you don’t miss any critical options.
• Baseline for further customization: The generated module serves as a starting point, which you can refine and extend to meet specific requirements.
• Automated validation and cleanup: It automatically validates and filters out computed-only attributes that should not be user-configurable.

For example, if you want to create a module for an AWS EC2 instance, instead of manually crafting thevariables.tf andmain.tf, you can runtmcg and instantly get:

1. Avariables.tf with all attributes defined and ready for customization.
2. Amain.tf implementing these variables with proper references.
3. Aversions.tf that enforces the required providers and Terraform version.

Usetmcg to specify resources and providers for your module. For instance:

tmcg --resource aws_instance:single --provider"hashicorp/aws:>=4.0" --directory my-module

Navigate to themy-module directory, where you’ll find:

• versions.tf: Ensures compatibility with the required Terraform version and provider version.
• variables.tf: Includes all possible attributes for theaws_instance resource.
• main.tf: Implements the logic based on the variables.

From here, you can further tailor the module to fit your use case.

Run Terraform commands to validate and test the module:

terraform initterraform validate

tmcg ensures the code is clean and adheres to best practices, reducing manual effort and errors.

• Time-saving: Quickly generate a baseline for Terraform modules, avoiding repetitive tasks.
• Up-to-date: Leverage the latest upstream provider schemas to ensure compatibility with the newest features.
• Customization-friendly: The generated code is easy to expand and customize, making it suitable for real-world use.

A DevOps/TechOps engineer responsible for setting up cloud infrastructure can usetmcg to:

1. Generate a module for managing EC2 instances.
2. Quickly iterate over configurations for different environments (e.g., staging, production) by modifying the generatedvariables.tf.
3. Stay compatible with the latest AWS provider by regenerating the module as provider schemas evolve.

By streamlining the module creation process,tmcg lets you focus on high-value tasks like optimizing resource configurations and scaling infrastructure.

Contributions are welcome! Feel free to fork the repository and submit pull requests.

Special thanks to:

• @benjy44 and@hampusrosvall for inspiring this project.
• Terraform for its amazing tooling and APIs.
• Go community for the fantastic libraries used in this project.
• ChatGPT for guiding and assisting in creating this tool and documentation.