Python脚本如何生成Terraform配置

wen 实用脚本 2026-07-09 230

本文目录导读：

使用字符串模板 (最简单)
使用Jinja2模板 (更灵活)
使用JSON/YAML中间格式 (适合复杂配置)
高级：使用Python类封装
批量生成多个环境配置
使用建议

我来详细介绍几种使用Python生成Terraform配置的方法。

使用字符串模板 (最简单)

# terraform_generator.py
def generate_vpc_config(vpc_cidr, vpc_name):
    config = f"""
resource "aws_vpc" "{vpc_name}" {{
  cidr_block = "{vpc_cidr}"
  tags = {{
    Name = "{vpc_name}"
    Environment = "production"
  }}
}}
"""
    return config
def generate_subnet_config(vpc_name, subnet_cidr, subnet_name, az):
    config = f"""
resource "aws_subnet" "{subnet_name}" {{
  vpc_id     = aws_vpc.{vpc_name}.id
  cidr_block = "{subnet_cidr}"
  availability_zone = "{az}"
  tags = {{
    Name = "{subnet_name}"
  }}
}}
"""
    return config
# 生成完整配置
def generate_full_config():
    config = """
# 生成的基础设施配置
terraform {{
  required_version = ">= 1.0"
  required_providers {{
    aws = {{
      source  = "hashicorp/aws"
      version = "~> 4.0"
    }}
  }}
}}
provider "aws" {{
  region = "us-east-1"
}}
"""
    config += generate_vpc_config("10.0.0.0/16", "main_vpc")
    config += generate_subnet_config("main_vpc", "10.0.1.0/24", "public_subnet", "us-east-1a")
    return config
# 写入文件
with open("main.tf", "w") as f:
    f.write(generate_full_config())
print("Terraform 配置已生成!")

使用Jinja2模板 (更灵活)

# 安装: pip install jinja2
from jinja2 import Environment, FileSystemLoader
import json
# 模板文件: templates/terraform_template.j2
template_str = """
# 生成的基础设施配置
terraform {
  required_version = ">= {{ terraform_version }}"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> {{ aws_provider_version }}"
    }
  }
}
provider "aws" {
  region = "{{ region }}"
}
{% for resource in resources %}
resource "{{ resource.type }}" "{{ resource.name }}" {
  {% for key, value in resource.attributes.items() %}
  {{ key }} = "{{ value }}"
  {% endfor %}
  tags = {
    Name = "{{ resource.name }}"
    Environment = "{{ environment }}"
  }
}
{% endfor %}
"""
# 生成配置的Python脚本
def generate_terraform_config():
    # 数据定义
    data = {
        "terraform_version": "1.0",
        "aws_provider_version": "4.0",
        "region": "us-east-1",
        "environment": "production",
        "resources": [
            {
                "type": "aws_vpc",
                "name": "main_vpc",
                "attributes": {
                    "cidr_block": "10.0.0.0/16",
                    "enable_dns_hostnames": "true"
                }
            },
            {
                "type": "aws_subnet",
                "name": "public_subnet",
                "attributes": {
                    "vpc_id": "aws_vpc.main_vpc.id",
                    "cidr_block": "10.0.1.0/24",
                    "availability_zone": "us-east-1a"
                }
            }
        ]
    }
    # 渲染模板
    env = Environment()
    template = env.from_string(template_str)
    config = template.render(**data)
    return config
# 生成配置文件
config = generate_terraform_config()
with open("generated_main.tf", "w") as f:
    f.write(config)
print("使用Jinja2生成的Terraform配置已保存!")

使用JSON/YAML中间格式 (适合复杂配置)

import json
import yaml
def generate_from_json():
    # 定义资源结构
    resources = {
        "terraform": {
            "required_version": ">= 1.0",
            "required_providers": {
                "aws": {
                    "source": "hashicorp/aws",
                    "version": "~> 4.0"
                },
                "random": {
                    "source": "hashicorp/random",
                    "version": "~> 3.0"
                }
            }
        },
        "provider": {
            "aws": {
                "region": "us-east-1"
            }
        },
        "resource": [
            {
                "aws_vpc": {
                    "main": {
                        "cidr_block": "10.0.0.0/16",
                        "tags": {
                            "Name": "main_vpc",
                            "Environment": "production"
                        }
                    }
                }
            },
            {
                "aws_subnet": {
                    "public": {
                        "vpc_id": "${aws_vpc.main.id}",
                        "cidr_block": "10.0.1.0/24",
                        "availability_zone": "us-east-1a"
                    }
                }
            }
        ]
    }
    return json.dumps(resources, indent=2)
def generate_from_yaml():
    # YAML配置示例
    yaml_config = """
terraform:
  required_version: ">= 1.0"
  required_providers:
    aws:
      source: "hashicorp/aws"
      version: "~> 4.0"
provider:
  aws:
    region: "us-east-1"
resources:
  - type: aws_vpc
    name: main
    attributes:
      cidr_block: "10.0.0.0/16"
      enable_dns_support: true
      enable_dns_hostnames: true
  - type: aws_subnet
    name: public
    attributes:
      vpc_id: "${aws_vpc.main.id}"
      cidr_block: "10.0.1.0/24"
      availability_zone: "us-east-1a"
"""
    # 解析YAML
    config_dict = yaml.safe_load(yaml_config)
    # 转换为Terraform格式
    terraform_output = []
    # 添加terraform块
    tf_block = f'''terraform {{
  required_version = "{config_dict['terraform']['required_version']}"
  required_providers {{
    aws = {{
      source  = "{config_dict['terraform']['required_providers']['aws']['source']}"
      version = "~> {config_dict['terraform']['required_providers']['aws']['version']}"
    }}
  }}
}}
'''
    terraform_output.append(tf_block)
    # 添加provider
    provider_block = f'''provider "aws" {{
  region = "{config_dict['provider']['aws']['region']}"
}}
'''
    terraform_output.append(provider_block)
    # 添加资源
    for resource in config_dict['resources']:
        resource_block = f'resource "{resource["type"]}" "{resource["name"]}" {{\n'
        for key, value in resource['attributes'].items():
            if isinstance(value, dict):
                resource_block += f'  {key} = {{\n'
                for k, v in value.items():
                    resource_block += f'    {k} = "{v}"\n'
                resource_block += '  }\n'
            else:
                resource_block += f'  {key} = "{value}"\n'
        resource_block += '}\n\n'
        terraform_output.append(resource_block)
    return ''.join(terraform_output)
# 生成并保存配置
config = generate_from_yaml()
with open("yaml_generated.tf", "w") as f:
    f.write(config)
print("从YAML生成的配置已保存!")

高级：使用Python类封装

class TerraformGenerator:
    def __init__(self, provider="aws", region="us-east-1"):
        self.provider = provider
        self.region = region
        self.resources = []
        self.providers = []
        self.variables = {}
    def add_resource(self, resource_type, resource_name, **attributes):
        self.resources.append({
            "type": resource_type,
            "name": resource_name,
            "attributes": attributes
        })
    def add_variable(self, var_name, var_type="string", default=None):
        self.variables[var_name] = {
            "type": var_type,
            "default": default
        }
    def generate(self):
        config = f"""
# 自动生成的Terraform配置
terraform {{
  required_version = ">= 1.0"
  required_providers {{
    aws = {{
      source  = "hashicorp/aws"
      version = "~> 4.0"
    }}
  }}
}}
provider "aws" {{
  region = "{self.region}"
}}
"""
        # 添加变量
        if self.variables:
            config += "\n# Variables\n"
            for var_name, var_data in self.variables.items():
                config += f'variable "{var_name}" {{\n'
                config += f'  type = "{var_data["type"]}"\n'
                if var_data["default"] is not None:
                    config += f'  default = "{var_data["default"]}"\n'
                config += '}\n\n'
        # 添加资源
        for resource in self.resources:
            config += f'resource "{resource["type"]}" "{resource["name"]}" {{\n'
            for key, value in resource["attributes"].items():
                if isinstance(value, bool):
                    config += f'  {key} = {"true" if value else "false"}\n'
                elif isinstance(value, (int, float)):
                    config += f'  {key} = {value}\n'
                else:
                    config += f'  {key} = "{value}"\n'
            config += '}\n\n'
        return config
    def save(self, filename="generated.tf"):
        config = self.generate()
        with open(filename, "w") as f:
            f.write(config)
        print(f"配置已保存到 {filename}")
# 使用示例
generator = TerraformGenerator(region="us-east-1")
# 添加变量
generator.add_variable("vpc_cidr", default="10.0.0.0/16")
generator.add_variable("environment", default="production")
# 添加资源
generator.add_resource("aws_vpc", "main",
    cidr_block="10.0.0.0/16",
    enable_dns_hostnames=True,
    tags={"Name": "main_vpc", "Environment": "production"}
)
generator.add_resource("aws_subnet", "public",
    vpc_id="${aws_vpc.main.id}",
    cidr_block="10.0.1.0/24",
    availability_zone="us-east-1a"
)
# 保存配置
generator.save("generated_infra.tf")

批量生成多个环境配置

def batch_generate_environments():
    environments = {
        "dev": {"region": "us-east-1", "vpc_cidr": "10.0.0.0/16"},
        "staging": {"region": "us-east-2", "vpc_cidr": "10.1.0.0/16"},
        "prod": {"region": "us-west-2", "vpc_cidr": "10.2.0.0/16"}
    }
    for env_name, env_config in environments.items():
        generator = TerraformGenerator(region=env_config["region"])
        # 添加环境特定的配置
        generator.add_resource("aws_vpc", f"{env_name}_vpc",
            cidr_block=env_config["vpc_cidr"],
            enable_dns_hostnames=True,
            tags={"Name": f"{env_name}_vpc", "Environment": env_name}
        )
        # 保存到不同的文件或目录
        generator.save(f"environments/{env_name}/main.tf")
        print(f"已生成 {env_name} 环境的配置")
# 批量生成
import os
os.makedirs("environments", exist_ok=True)
batch_generate_environments()