Terraform Provider Framework中map[string]interface{}与[]interface{}的使用问题

我正尝试构建一个可处理任意map和list输入的Terraform Provider（使用Provider Framework）。上游API期望的JSON负载格式如下：

name: string
input1: map(any)
input2: list(any)

示例负载包括：

{
  "name": "foobar",
  "input1":  {
      "apple": "tree"
    },
  "input2": ["hello", 123]
}

以及嵌套结构的负载：

{
  "name": "foobaz",
  "input1":  {
      "this": {
         "is": "nested"
      },
     "this-though": "isnt"
    },
  "input2": [{"here": "things"}]
}

API客户端中定义的负载结构体为：

type MyModel struct {
    Name   string                 `json:"name,omitempty"`
    Input1 map[string]interface{} `json:"input1,omitempty"`
    Input2 []interface{}          `json:"input2,omitempty"`
}

但在资源Schema定义中，不确定input1和input2应使用什么属性类型；同时在Create方法实现中，不知道如何在myModelModel与client.MyModel之间进行数据转换。

1. 资源Schema的正确属性类型 #

要支持任意类型（包括嵌套结构）的map和list，需要使用schema.MapAttribute和schema.ListAttribute，并将它们的ElementType设置为schema.DynamicAttributeType——Dynamic类型可以处理任意Terraform值类型，包括嵌套的map、list、基本类型等。

修改后的Schema代码：

resp.Schema = schema.Schema{
    Description: "Manages a smart contract.",
    Attributes: map[string]schema.Attribute{
        "id": schema.StringAttribute{
            Computed: true,
        },
        "name": schema.StringAttribute{
            Required: true,
        },
        "input1": schema.MapAttribute{
            Required: true,
            ElementType: schema.DynamicAttributeType{},
        },
        "input2": schema.ListAttribute{
            Required: true,
            ElementType: schema.DynamicAttributeType{},
        },
    },
}

注意：Terraform Provider Framework中属性名称通常使用小写（如id而非ID），保持与Terraform生态的命名一致性。

2. 数据转换实现 #

对应的myModelModel结构体（由Provider Framework代码生成工具生成）中，Input1的类型会是types.Map[types.Dynamic]，Input2的类型会是types.List[types.Dynamic]。以下是具体的转换逻辑：

从myModelModel到client.MyModel #

// Create方法中转换plan到client模型
newMyModel := client.MyModel{
    Name: plan.Name.ValueString(),
}

// 转换Input1: types.Map[types.Dynamic] -> map[string]interface{}
if !plan.Input1.IsNull() {
    input1Map := make(map[string]interface{})
    for k, v := range plan.Input1.ValueMap() {
        input1Map[k] = v.Value
    }
    newMyModel.Input1 = input1Map
}

// 转换Input2: types.List[types.Dynamic] -> []interface{}
if !plan.Input2.IsNull() {
    input2Slice := make([]interface{}, len(plan.Input2.ValueList()))
    for i, v := range plan.Input2.ValueList() {
        input2Slice[i] = v.Value
    }
    newMyModel.Input2 = input2Slice
}

从client.MyModel到myModelModel #

当API返回数据后，需要将客户端结构体转换回框架模型，以便设置到状态中：

// 转换API返回的myModel到plan
plan.Name = types.StringValue(myModel.Name)

// 转换Input1: map[string]interface{} -> types.Map[types.Dynamic]
if myModel.Input1 != nil {
    dynamicMap := make(map[string]types.Dynamic, len(myModel.Input1))
    for k, v := range myModel.Input1 {
        dynamicMap[k] = types.DynamicValue(v)
    }
    plan.Input1 = types.MapValueMust(types.DynamicType, dynamicMap)
} else {
    plan.Input1 = types.MapNull(types.DynamicType)
}

// 转换Input2: []interface{} -> types.List[types.Dynamic]
if myModel.Input2 != nil {
    dynamicSlice := make([]types.Dynamic, len(myModel.Input2))
    for i, v := range myModel.Input2 {
        dynamicSlice[i] = types.DynamicValue(v)
    }
    plan.Input2 = types.ListValueMust(types.DynamicType, dynamicSlice)
} else {
    plan.Input2 = types.ListNull(types.DynamicType)
}

完整的Create方法示例 #

// Create a new resource.
func (r *myModelResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
    // Retrieve values from plan
    var plan myModelModel
    diags := req.Plan.Get(ctx, &plan)
    resp.Diagnostics.Append(diags...)
    if resp.Diagnostics.HasError() {
        return
    }

    // Convert plan to client MyModel
    newMyModel := client.MyModel{
        Name: plan.Name.ValueString(),
    }

    // Handle Input1 conversion
    if !plan.Input1.IsNull() {
        input1Map := make(map[string]interface{})
        for k, v := range plan.Input1.ValueMap() {
            input1Map[k] = v.Value
        }
        newMyModel.Input1 = input1Map
    }

    // Handle Input2 conversion
    if !plan.Input2.IsNull() {
        input2Slice := make([]interface{}, len(plan.Input2.ValueList()))
        for i, v := range plan.Input2.ValueList() {
            input2Slice[i] = v.Value
        }
        newMyModel.Input2 = input2Slice
    }

    // Call API to create MyModel
    myModel, err := r.client.CreateMyModel(newMyModel)
    if err != nil {
        resp.Diagnostics.AddError(
            "Error Creating MyModel",
            "Could not create MyModel: "+err.Error(),
        )
        return
    }

    // Convert API response back to plan model
    plan.Name = types.StringValue(myModel.Name)

    // Convert Input1 from API response
    if myModel.Input1 != nil {
        dynamicMap := make(map[string]types.Dynamic, len(myModel.Input1))
        for k, v := range myModel.Input1 {
            dynamicMap[k] = types.DynamicValue(v)
        }
        plan.Input1 = types.MapValueMust(types.DynamicType, dynamicMap)
    } else {
        plan.Input1 = types.MapNull(types.DynamicType)
    }

    // Convert Input2 from API response
    if myModel.Input2 != nil {
        dynamicSlice := make([]types.Dynamic, len(myModel.Input2))
        for i, v := range myModel.Input2 {
            dynamicSlice[i] = types.DynamicValue(v)
        }
        plan.Input2 = types.ListValueMust(types.DynamicType, dynamicSlice)
    } else {
        plan.Input2 = types.ListNull(types.DynamicType)
    }

    // Set state to fully populated data
    diags = resp.State.Set(ctx, plan)
    resp.Diagnostics.Append(diags...)
    if resp.Diagnostics.HasError() {
        return
    }
}

内容的提问来源于stack exchange，提问作者Karl