本文目录导读：
我来详细介绍几种使用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()
使用建议
- 简单配置：使用字符串模板或Jinja2
- 复杂配置：使用JSON/YAML作为中间格式
- 模块化需求：使用类封装的方法
- 批量处理：实现循环生成多个环境配置
这些方法可以帮助你自动化生成Terraform配置,避免手动编写重复代码。
