腾讯云支持 Terraform 开发实践

cd  $GOPATH/src/github.com/tencentyun/terraform-provider-tencentcloud

├─terraform-provider-tencentcloud                    根目录
│  ├─main.go                                         程序入口文件
│  ├─AUTHORS                                         作者信息
│  ├─CHANGELOG.md                                    变更日志
│  ├─LICENSE                                         授权信息
│  ├─debug.tf.example                                调试配置文件示例
│  ├─examples                                        示例配置文件目录
│  │  ├─tencentcloud-eip                             EIP示例tf文件
│  │  ├─tencentcloud-instance                        CVM示例tf文件
│  │  ├─tencentcloud-nat                             NAT网关示例tf文件
│  │  ├─tencentcloud-vpc                             VPC示例tf文件
│  │  └─ ...                                         更多examples目录
│  ├─tencentcloud                                    Provider核心目录
│  │  ├─basic_test.go                                基础单元测试
│  │  ├─config.go                                    公共配置文件
│  │  ├─data_source_tc_availability_zones.go         可用区查询
│  │  ├─data_source_tc_availability_zones_test.go
│  │  ├─data_source_tc_nats.go                       NAT网关列表查询
│  │  ├─data_source_tc_nats_test.go
│  │  ├─data_source_tc_vpc.go                        VPC查询
│  │  ├─data_source_tc_vpc_test.go
│  │  ├─...                                          更多Data Source
│  │  ├─helper.go                                    一些公共函数
│  │  ├─provider.go                                  Provider核心文件
│  │  ├─provider_test.go
│  │  ├─resource_tc_eip.go                           EIP资源管理程序
│  │  ├─resource_tc_eip_test.go
│  │  ├─resource_tc_instance.go                      CVM实例资源管理程序
│  │  ├─resource_tc_instance_test.go
│  │  ├─resource_tc_nat_gateway.go                   NAT网关资源管理程序
│  │  ├─resource_tc_nat_gateway_test.go
│  │  ├─resource_tc_vpc.go                           VPC网关资源管理程序
│  │  ├─resource_tc_vpc_test.go
│  │  ├─...                                          更多资源管理程序
│  │  ├─service_eip.go                               封装的EIP相关Service
│  │  ├─service_instance.go                          封装的CVM实例相关Service
│  │  ├─service_vpc.go                               封装的VPC相关Service
│  │  ├─...
│  │  ├─validators.go                                公共的参数校验函数
│  ├─vendor                                          依赖的第三方库
│  ├─website                                         Web相关文件
│  │  ├─tencentcloud.erb                             文档左侧菜单栏
│  │  ├─docs                                         文档markdown源文件目录
│  │  │  ├─d                                         data相关文档（data_source_*）
│  │  │  │  ├─availability_zones.html.md
│  │  │  │  ├─nats.html.markdown
│  │  │  │  ├─vpc.html.markdown
│  │  │  │  ├─...
│  │  │  ├─index.html.markdown
│  │  │  ├─r                                         resource相关文档(resource_*)
│  │  │  │  ├─instance.html.markdown
│  │  │  │  ├─nat_gateway.html.markdown
│  │  │  │  ├─vpc.html.markdown
│  │  │  │  └─...

package tencentcloud

import (
    "github.com/hashicorp/terraform/helper/schema"
)

func resourceTencentCloudNatGateway() *schema.Resource {
    return &schema.Resource{
        Create: resourceTencentCloudNatGatewayCreate,
        Read:   resourceTencentCloudNatGatewayRead,
        Update: resourceTencentCloudNatGatewayUpdate,
        Delete: resourceTencentCloudNatGatewayDelete,

        Schema: map[string]*schema.Schema{
            "vpc_id": &schema.Schema{
                Type:     schema.TypeString,
                Required: true,
                ForceNew: true,
            },
            "name": &schema.Schema{
                Type:         schema.TypeString,
                Required:     true,
                ValidateFunc: validateStringLengthInRange(1, 60),
            },
            "max_concurrent": &schema.Schema{
                Type:     schema.TypeInt,
                Required: true,
            },
            "bandwidth": &schema.Schema{
                Type:     schema.TypeInt,
                Required: true,
            },
            "assigned_eip_set": &schema.Schema{
                Type:     schema.TypeSet,
                Required: true,
                Elem: &schema.Schema{
                    Type: schema.TypeString,
                },
                MinItems: 1,
                MaxItems: 10,
            },
        },
    }
}

func resourceTencentCloudNatGatewayCreate(d *schema.ResourceData, meta interface{}) error {
    return nil
}

func resourceTencentCloudNatGatewayRead(d *schema.ResourceData, meta interface{}) error {
    return nil
}

func resourceTencentCloudNatGatewayUpdate(d *schema.ResourceData, meta interface{}) error {
    return nil
}

func resourceTencentCloudNatGatewayDelete(d *schema.ResourceData, meta interface{}) error {
    return nil
}

func validateIp(v interface{}, k string) (ws []string, errors []error) {
    value := v.(string)
    ip := net.ParseIP(value)
    if ip == nil {
        errors = append(errors, fmt.Errorf("%q must contain a valid IP", k)) 
    }   
    return
}

import (
    "encoding/json"
    "errors"
    "fmt"
    "log"

    "github.com/hashicorp/terraform/helper/schema"
    "github.com/zqfan/tencentcloud-sdk-go/common"
    vpc "github.com/zqfan/tencentcloud-sdk-go/services/vpc/unversioned"
)

//...

func resourceTencentCloudNatGatewayCreate(d *schema.ResourceData, meta interface{}) error {
    return nil
}

func resourceTencentCloudNatGatewayRead(d *schema.ResourceData, meta interface{}) error {
    return nil
}

func resourceTencentCloudNatGatewayUpdate(d *schema.ResourceData, meta interface{}) error {
    return nil
}

func resourceTencentCloudNatGatewayDelete(d *schema.ResourceData, meta interface{}) error {
    return nil
}

func (d *ResourceData) Get(key string) interface{}

func (d *ResourceData) GetOk(key string) (interface{}, bool)

func (d *ResourceData) SetId(v string)

func (d *ResourceData) Id() string

func (d *ResourceData) Set(key string, value interface{}) error

func (d *ResourceData) HasChange(key string) bool

func (d *ResourceData) GetChange(key string) (interface{}, interface{})

func (d *ResourceData) Partial(on bool)

func (d *ResourceData) SetPartial(k string)

func resourceTencentCloudNatGatewayCreate(d *schema.ResourceData, meta interface{}) error {

    // 创建请求对象
    args := vpc.NewCreateNatGatewayRequest()

    // 给对象属性赋值，这里要注意，因为
    args.VpcId = common.StringPtr(d.Get("vpc_id").(string))
    args.NatName = common.StringPtr(d.Get("name").(string))

    // 因为 max_concurrent 和 bandwidth 是可选值，所以我们用 GetOk 判断用户是否配置
    if v, ok := d.GetOk("max_concurrent"); ok {
        args.MaxConcurrent = common.IntPtr(v.(int))
    }
    if v, ok := d.GetOk("bandwidth"); ok {
        args.Bandwidth = common.IntPtr(v.(int))
    }

    // assigned_eip_set 是个数组，取值方法和整型、字符串有点不一样，需要用 List 方法
    eips := d.Get("assigned_eip_set").(*schema.Set).List()
    args.AssignedEipSet = common.StringPtrs(expandStringList(eips))

    // 这里就是发送请求了
    client := meta.(*TencentCloudClient)
    conn := client.vpcConn
    response, err := conn.CreateNatGateway(args)
    b, _ := json.Marshal(response)
    log.Printf("[DEBUG] conn.CreateNatGateway response: %s", b)
    if _, ok := err.(*common.APIError); ok {
        return fmt.Errorf("conn.CreateNatGateway error: %v", err)
    }

    // 因为NAT网关的创建是异步的，到这里，我们只拿到了一个BillId，所以需要用到轮询逻辑了
    if _, err := client.PollingVpcBillResult(response.BillId); err != nil {
        return err
    }

    // 为了方便调试，我们把NAT网关ID记录到日志
    log.Printf("[DEBUG] conn.CreateNatGateway NatGatewayId: %s", *response.NatGatewayId)

    // 调用 SetId 写入资源ID（这里就是NAT网关ID），关于 SetId 方法的作用，参考前面说的
    d.SetId(*response.NatGatewayId)
    return nil
}

func (client *TencentCloudClient) PollingVpcBillResult(billId *string) (status bool, err error) {
    queryReq := vpc.NewQueryNatGatewayProductionStatusRequest()
    queryReq.BillId = billId
    status = false
    // 设置超时时间为3分钟
    err = resource.Retry(3*time.Minute, func() *resource.RetryError {
        queryResp, err := client.vpcConn.QueryNatGatewayProductionStatus(queryReq)
        b, _ := json.Marshal(queryResp)
        log.Printf("[DEBUG] client.vpcConn.QueryNatGatewayProductionStatus response: %s", b)
        if _, ok := err.(*common.APIError); ok {
            // 返回 NonRetryableError 错误，resource 会退出重试，并返回错误信息
            return resource.NonRetryableError(fmt.Errorf("client.vpcConn.QueryNatGatewayProductionStatus error: %v", err))
        }   
        // 返回 nil 之后，表示操作成功，resource 就会退出重试
        if *queryResp.Data.Status == vpc.BillStatusSuccess {
            return nil 
        }  
        // 返回一个 RetryableError 错误，resource 将持续重试
        return resource.RetryableError(fmt.Errorf("billId %v, not ready, status: %v", billId, *queryResp.Data.Status))
    })  
    return
}

func resourceTencentCloudNatGatewayRead(d *schema.ResourceData, meta interface{}) error {

    conn := meta.(*TencentCloudClient).vpcConn

    descReq := vpc.NewDescribeNatGatewayRequest()
    descReq.NatId = common.StringPtr(d.Id())

    descResp, err := conn.DescribeNatGateway(descReq)
    b, _ := json.Marshal(descResp)
    log.Printf("[DEBUG] conn.DescribeNatGateway response: %s", b)
    if _, ok := err.(*common.APIError); ok {
        return fmt.Errorf("conn.DescribeNatGateway error: %v", err)
    }

    // 未找到资源时，为什么不报错？SetId("") 又是什么意思？
    if *descResp.TotalCount == 0 || len(descResp.Data) == 0 {
        d.SetId("")
        return nil 
    } else if err != nil {
        return err
    }

    nat := descResp.Data[0]

    d.Set("name", *nat.NatName)
    d.Set("max_concurrent", *nat.MaxConcurrent)
    d.Set("bandwidth", *nat.Bandwidth)
    d.Set("assigned_eip_set", nat.EipSet)
    return nil
}

func resourceTencentCloudNatGatewayUpdate(d *schema.ResourceData, meta interface{}) error {

    client := meta.(*TencentCloudClient)
    conn := client.vpcConn

    // 开启 允许部分属性修改 功能
    d.Partial(true)

    // 标识是否有修改
    attributeUpdate := false

    updateReq := vpc.NewModifyNatGatewayRequest()
    updateReq.VpcId = common.StringPtr(d.Get("vpc_id").(string))
    updateReq.NatId = common.StringPtr(d.Id())

    // 修改NAT网关名称
    if d.HasChange("name") {
        d.SetPartial("name")
        var name string
        if v, ok := d.GetOk("name"); ok {
            name = v.(string)
        } else {
            return fmt.Errorf("cann't change name to empty string")
        }
        updateReq.NatName = common.StringPtr(name)

        attributeUpdate = true
    }

    // 修改带宽上限
    if d.HasChange("bandwidth") {
        d.SetPartial("bandwidth")
        var bandwidth int
        if v, ok := d.GetOk("bandwidth"); ok {
            bandwidth = v.(int)
        } else {
            return fmt.Errorf("cann't change bandwidth to empty string")
        }
        updateReq.Bandwidth = common.IntPtr(bandwidth)

        attributeUpdate = true
    }

    // 修改名称和带宽上限，用的同一个接口，如果有修改，就提交
    if attributeUpdate {
        updateResp, err := conn.ModifyNatGateway(updateReq)
        b, _ := json.Marshal(updateResp)
        log.Printf("[DEBUG] conn.ModifyNatGateway response: %s", b)
        if _, ok := err.(*common.APIError); ok {
            return fmt.Errorf("conn.ModifyNatGateway error: %v", err)
        }
    }

    // 修改并发连接数上限，这里用到了 GetChange，对比新旧数据
    // 因为我们的NAT网关的并发连接数上限，只能升不能降
    if d.HasChange("max_concurrent") {
        d.SetPartial("max_concurrent")
        old_mc, new_mc := d.GetChange("max_concurrent")
        old_max_concurrent := old_mc.(int)
        new_max_concurrent := new_mc.(int)
        if new_max_concurrent <= old_max_concurrent {
            return fmt.Errorf("max_concurrent only supports upgrade")
        }
        upgradeReq := vpc.NewUpgradeNatGatewayRequest()
        upgradeReq.VpcId = updateReq.VpcId
        upgradeReq.NatId = updateReq.NatId
        upgradeReq.MaxConcurrent = common.IntPtr(new_max_concurrent)

        upgradeResp, err := conn.UpgradeNatGateway(upgradeReq)
        b, _ := json.Marshal(upgradeResp)
        log.Printf("[DEBUG] conn.UpgradeNatGateway response: %s", b)
        if _, ok := err.(*common.APIError); ok {
            return fmt.Errorf("conn.UpgradeNatGateway error: %v", err)
        }

        if _, err := client.PollingVpcBillResult(upgradeResp.BillId); err != nil {
            return err
        }
    }

    // 修改关联弹性EIP，这块逻辑稍微复杂点，因为 `assigned_eip_set` 是个数组
    // 我们需要对比新旧数据，拿到用户删除的数组元素和增加的数组元素
    // 然后调用解绑接口，解绑用户删除的数组元素；再调用绑定接口，绑定用户增加的数组元素
    if d.HasChange("assigned_eip_set") {
        o, n := d.GetChange("assigned_eip_set")
        os := o.(*schema.Set)
        ns := n.(*schema.Set)

        old_eip_set := os.List()
        new_eip_set := ns.List()

        if len(old_eip_set) > 0 && len(new_eip_set) > 0 {

            // Unassign old EIP
            unassignIps := os.Difference(ns)
            if unassignIps.Len() != 0 {
                unbindReq := vpc.NewEipUnBindNatGatewayRequest()
                unbindReq.VpcId = updateReq.VpcId
                unbindReq.NatId = updateReq.NatId
                unbindReq.AssignedEipSet = common.StringPtrs(expandStringList(unassignIps.List()))
                unbindResp, err := conn.EipUnBindNatGateway(unbindReq)
                b, _ := json.Marshal(unbindResp)
                log.Printf("[DEBUG] conn.EipUnBindNatGateway response: %s", b)
                if _, ok := err.(*common.APIError); ok {
                    return fmt.Errorf("conn.EipUnBindNatGateway error: %v", err)
                }

                if _, err := client.PollingVpcTaskResult(unbindResp.TaskId); err != nil {
                    return err
                }
            }

            // Assign new EIP
            assignIps := ns.Difference(os)
            if assignIps.Len() != 0 {
                bindReq := vpc.NewEipBindNatGatewayRequest()
                bindReq.VpcId = updateReq.VpcId
                bindReq.NatId = updateReq.NatId
                bindReq.AssignedEipSet = common.StringPtrs(expandStringList(assignIps.List()))
                bindResp, err := conn.EipBindNatGateway(bindReq)
                b, _ := json.Marshal(bindResp)
                log.Printf("[DEBUG] conn.EipBindNatGateway response: %s", b)
                if _, ok := err.(*common.APIError); ok {
                    return fmt.Errorf("conn.EipBindNatGateway error: %v", err)
                }

                if _, err := client.PollingVpcTaskResult(bindResp.TaskId); err != nil {
                    return err
                }
            }

        } else {
            return errEipUnassigned
        }

        d.SetPartial("assigned_eip_set")
    }

    // 关闭 允许部分属性修改 功能
    d.Partial(false)

    return nil
}

func resourceTencentCloudNatGatewayDelete(d *schema.ResourceData, meta interface{}) error {

    client := meta.(*TencentCloudClient)

    deleteReq := vpc.NewDeleteNatGatewayRequest()
    deleteReq.VpcId = common.StringPtr(d.Get("vpc_id").(string))
    deleteReq.NatId = common.StringPtr(d.Id())

    deleteResp, err := client.vpcConn.DeleteNatGateway(deleteReq)
    b, _ := json.Marshal(deleteResp)
    log.Printf("[DEBUG] client.vpcConn.DeleteNatGateway response: %s", b)
    if _, ok := err.(*common.APIError); ok {
        return fmt.Errorf("[ERROR] client.vpcConn.DeleteNatGateway error: %v", err)
    }

    _, err = client.PollingVpcTaskResult(deleteResp.TaskId)
    return err
}

go build -o terraform-provider-tencentcloud

terrform plan
terrform apply

package tencentcloud

import (
    "encoding/json"
    "fmt"
    "log"
    "testing"

    "github.com/hashicorp/terraform/helper/resource"
    "github.com/hashicorp/terraform/terraform"
    "github.com/zqfan/tencentcloud-sdk-go/common"
    vpc "github.com/zqfan/tencentcloud-sdk-go/services/vpc/unversioned"
)

func TestAccTencentCloudNatGateway_basic(t *testing.T) {
    resource.Test(t, resource.TestCase{
        PreCheck:     func() { testAccPreCheck(t) },
        Providers:    testAccProviders,
        // 配置 资源销毁结果检查函数
        CheckDestroy: testAccCheckNatGatewayDestroy,
        // 配置 测试步骤
        Steps: []resource.TestStep{
            {
                // 配置 配置内容
                Config: testAccNatGatewayConfig,
                // 配置 验证函数
                Check: resource.ComposeTestCheckFunc(
                    // 验证资源ID
                    testAccCheckTencentCloudDataSourceID("tencentcloud_nat_gateway.my_nat"),
                    // 验证资源属性，能匹配到，肯定就是创建成功了
                    resource.TestCheckResourceAttr("tencentcloud_nat_gateway.my_nat", "name", "terraform_test"),
                    resource.TestCheckResourceAttr("tencentcloud_nat_gateway.my_nat", "max_concurrent", "3000000"),
                    resource.TestCheckResourceAttr("tencentcloud_nat_gateway.my_nat", "bandwidth", "500"),
                    resource.TestCheckResourceAttr("tencentcloud_nat_gateway.my_nat", "assigned_eip_set.#", "2"),
                ),
            },
            {
                // 配置 配置内容
                Config: testAccNatGatewayConfigUpdate,
                Check: resource.ComposeTestCheckFunc(
                    testAccCheckTencentCloudDataSourceID("tencentcloud_nat_gateway.my_nat"),
                    // 验证修改后的属性值，如果能匹配到，肯定就是修改成功了
                    resource.TestCheckResourceAttr("tencentcloud_nat_gateway.my_nat", "name", "new_name"),
                    resource.TestCheckResourceAttr("tencentcloud_nat_gateway.my_nat", "max_concurrent", "10000000"),
                    resource.TestCheckResourceAttr("tencentcloud_nat_gateway.my_nat", "bandwidth", "1000"),
                    resource.TestCheckResourceAttr("tencentcloud_nat_gateway.my_nat", "assigned_eip_set.#", "2"),
                ),
            },
        },
    })
}

// testAccProviders 在测试前会根据 Config 建立测试资源，测试结束后又会全部销毁
// 这个函数就是检查资源是否销毁用的，代码逻辑比较好理解，就是根据ID查询资源是否存在
func testAccCheckNatGatewayDestroy(s *terraform.State) error {

    conn := testAccProvider.Meta().(*TencentCloudClient).vpcConn

    // 这用到了 s.RootModule().Resources 数组
    // 这个数组的属性反应的就是资源状态文件 terraform.tfstate
    for _, rs := range s.RootModule().Resources {
        if rs.Type != "tencentcloud_nat_gateway" {
            continue
        }

        descReq := vpc.NewDescribeNatGatewayRequest()
        descReq.NatId = common.StringPtr(rs.Primary.ID)
        descResp, err := conn.DescribeNatGateway(descReq)

        b, _ := json.Marshal(descResp)

        log.Printf("[DEBUG] conn.DescribeNatGateway response: %s", b)

        if _, ok := err.(*common.APIError); ok {
            return fmt.Errorf("conn.DescribeNatGateway error: %v", err)
        } else if *descResp.TotalCount != 0 {
            return fmt.Errorf("NAT Gateway still exists.")
        }
    }
    return nil
}

// 基本用法配置文件，机智的你，一定发现了，这不是和debug用的tf文件一样一样的么
const testAccNatGatewayConfig = `
resource "tencentcloud_vpc" "main" {
  name       = "terraform test"
  cidr_block = "10.6.0.0/16"
}
resource "tencentcloud_eip" "eip_dev_dnat" {
  name = "terraform_test"
}
resource "tencentcloud_eip" "eip_test_dnat" {
  name = "terraform_test"
}

resource "tencentcloud_nat_gateway" "my_nat" {
  vpc_id           = "${tencentcloud_vpc.main.id}"
  name             = "terraform_test"
  max_concurrent   = 3000000
  bandwidth        = 500 
  assigned_eip_set = [ 
    "${tencentcloud_eip.eip_dev_dnat.public_ip}",
    "${tencentcloud_eip.eip_test_dnat.public_ip}",
  ]
}
`

// 修改用法配置文件，机智的你一定发现了，这不就是和debug修改后的tf文件一样一样的么
const testAccNatGatewayConfigUpdate = `
resource "tencentcloud_vpc" "main" {
  name       = "terraform test"
  cidr_block = "10.6.0.0/16"
}
resource "tencentcloud_eip" "eip_dev_dnat" {
  name = "terraform_test"
}
resource "tencentcloud_eip" "eip_test_dnat" {
  name = "terraform_test"
}
resource "tencentcloud_eip" "new_eip" {
  name = "terraform_test"
}

resource "tencentcloud_nat_gateway" "my_nat" {
  vpc_id           = "${tencentcloud_vpc.main.id}"
  name             = "new_name"
  max_concurrent   = 10000000
  bandwidth        = 1000 
  assigned_eip_set = [ 
    "${tencentcloud_eip.eip_dev_dnat.public_ip}",
    "${tencentcloud_eip.new_eip.public_ip}",
  ]
}
`

export TF_ACC=true
cd tencentcloud
go test -i; go test -test.run TestAccTencentCloudNatGateway_basic -v