基础设施即代码(Infrastructure as Code， IaC)仍是成为云时间DevOps实践中不成或缺的一环。通过代码来管制和设立基础设施，咱们不错像开拓软件一样成人游戏下载，用工程化的设施来对待基础设施。在IaC规模，Terraform无疑是最流行的用具之一。

1、Terraform和Provider简介

Terraform是一个用于安全高效地构建、革新和版块死心基础设施的用具。它通过一种声明式的话语(HCL)来样貌基础设施的祈望情景，然后根据这些样貌自动化地创建和管制资源。

本色来说，Terraform是一个情景管制用具，对其管制的资源履行CRUD操作，被其托管的资源好多时辰是基于云的，但是也不错用其托管其他资源，表面上能通过CRUD抒发的猖狂资源皆不错通过其托管。

在 Terraform 中，Provider 是 Terraform 的中枢组件之一，用于概述化与特定云做事或其他基础设施资源的交互。它是一种插件，充任了 Terraform 和外部系统之间的桥梁，允许 Terraform 管制、创建、修改和删以外部资源。每个Provider郑重一类特定的资源，例如AWS Provider允许咱们管制EC2实例、S3存储桶等AWS资源。Terraform通过丰富的Provider生态，救援管制确切统统主流的云资源。

Provider的主邀功能

1.资源管制

界说不错创建、修改和删除的资源类型。

2.数据源查询

界说只读的数据源，用于从外部系统取得信息。

3.情景同步

Provider 通过 API 调用取得资源确现时情景，与 Terraform 的情景文献保握一致。

诚然Terraform内置了丰富的Provider救援，但在某些场景下，表率Provider可能无法倨傲业务需求。这时，开拓一个自界说的Provider成为了处理问题的要津期间。

那么，什么情况下咱们需要创建一个自界说的Provider呢？

救援自界说资源：如果你的基础设施中包含了一些自界说资源或做事（例如里面开拓的独到云平台、专有 API 或者公司特定的用具），而这些资源并未被官方提供的 Terraform Providers 救援，那么开拓一个自界说 Provider 就不错将这些资源纳入基础设施即代码（IaC）的管制中。做事开放：如果你的做事将来要面向外部客户开放，一个自界说 Provider 不错行为基础设施自动化的高大构成部分，方便客户通过 Terraform 集成你的做事。膨大现存Provider：如果现存的Provider 并未倨傲你的需求（例如，贫苦某些资源类型的救援，或者对资源的操作不够活泼），通过自界说 Provider 不错对其进行膨大。

2、开拓自界说Provider

在脱手干预这个主题之前，咱们先了解下Provider的统统这个词使命进程：

不错看到，Provider等于网络Terraform和具体做事API的桥梁。如果咱们想要终了一个管制独到云MySQL的Provider，其实调用的亦然咱们独到云我方的API，仅仅Terraform和Provider匡助了使用Terraform的用户解脱了我方对接独到云API的繁琐法子。

由此，咱们也不错知说念，如果咱们要开拓一个Provider，其实本色上等于完成对Terraform Provider的接口适配。

当今，HashiCorp提供了两个用于开拓 Terraform Provider 的SDK，Terraform Plugin Framework 和 Terraform Plugin SDK ，Terraform Plugin Framework是 HashiCorp 官方保举的新一代开拓框架，联想更当代化，况且基于 Go Context 和 gRPC，强调膨大性和模块化，救援更细粒度的死心，提供更好的类型安全救援。是以本文将剿袭Terraform Plugin Framework来进行Provider的开拓，也保举统统新的Provider皆剿袭官方的新框架。

1. 环境条目

1.Go 1.21+

2.Terraform v1.8+

3.我方的独到云API做事(或者猖狂你想对接的资源API皆不错)

国产xxx

2. Provider的资源界说

任何Terraform Provider的主要宗旨皆是为Terraform提供资源，资源主要有两种—resource（也不错称为托管资源）以及data sources（也不错称为数据源）。托管资源，通过终了创建、读取、更新和删除（CRUD）设施，救援完满的人命周期管制。而数据源则相对浅薄，仅终赫然CRUD中的读取（Read）部分。天然，也有一种相比特地的资源界说，也等于Provider自己。让咱们用aws的设立来例如：

Provider 界说

provider 块用来设立与具体做事的交互格式。常见的设立项包括认证信息、API 地址、默许区域等。

provider "aws" { region = "us-east-1" access_key = "your_access_key" secret_key = "your_secret_key"}

Resource 界说(以aws s3例如)

resource 块用于界说由 Provider 管制的具体资源，这些资源不错进行一齐的CRUD操作。

resource "aws_s3_bucket" "example_bucket" { bucket = "my-example-bucket" acl = "private" tags = { Name = "My bucket" Environment = "Dev" }}

3.Data Sources界说(以aws s3例如)

data 块主要用来界说一些外部做事的现存资源，而不是再去创建新资源。

data "aws_s3_bucket" "existing_bucket" { bucket = "existing-bucket-name"}

通过以上对于资源的界说，大约不错理出一个Provider的开拓限定，当先进行provider块部分联系的开拓，然后进行resource/data块联系的开拓。

2. provider结构联想

当先，咱们看下官方的SDK中对于provider的接口界说：

type Provider interface { // Metadata should return the metadata for the provider， such as // a type name and version data. // // Implementing the MetadataResponse.TypeName will populate the // datasource.MetadataRequest.ProviderTypeName and // resource.MetadataRequest.ProviderTypeName fields automatically. Metadata(context.Context， MetadataRequest， *MetadataResponse) // Schema should return the schema for this provider. Schema(context.Context， SchemaRequest， *SchemaResponse) // Configure is called at the beginning of the provider lifecycle， when // Terraform sends to the provider the values the user specified in the // provider configuration block. These are supplied in the // ConfigureProviderRequest argument. // Values from provider configuration are often used to initialise an // API client， which should be stored on the struct implementing the // Provider interface. Configure(context.Context， ConfigureRequest， *ConfigureResponse) // DataSources returns a slice of functions to instantiate each DataSource // implementation. // // The data source type name is determined by the DataSource implementing // the Metadata method. All data sources must have unique names. DataSources(context.Context) []func() datasource.DataSource // Resources returns a slice of functions to instantiate each Resource // implementation. // // The resource type name is determined by the Resource implementing // the Metadata method. All resources must have unique names. Resources(context.Context) []func() resource.Resource}

不错看到，如果咱们需要终了这个接口，需要终了Metadata，Schema，Configure，DataSources，Resources这几个设施。

Metadata 设施用于提供现时 Provider 的元数据信息，例如类型称号（TypeName）和版块等。这些信息不错用于识别 Provider，或者在需要与 Terraform 中枢交互时使用。

Schema 设施用于界说 Provider 的设立结构。例如，用户在 Terraform 中设立 Provider 的时辰，可能需要指定 API 的凭据或筹商地址。这些设立信息通过此设施界说。

Configure 设施用于脱手化 Provider 的运行环境。时时会暴露用户设立的参数（例如凭据或其他必要的脱手化信息），并生成一个客户端实例或其他联系的资源。

DataSources 设施复返 Provider 救援的所罕有据源类型。每个数据源用于从外部系统（如 API）中读取数据并将其提供给 Terraform。

Resources 设施复返 Provider 救援的统统托管资源类型。每个资源代表 Terraform 不错管制的一个实体成人游戏下载，例如云做事中的编造机、数据库实例等。

第一步，先想下咱们的Schema奈何终了。咱们仍是知说念，Schema设施用于界说 Provider 的设立结构，因为本文的例子是要开拓一个管制独到云MySQL的Provider，是以咱们对接的API做事等于智汇云的OpenAPI。通过智汇云的OpenAPI文档，咱们已知，如果要与其进行交互，需要Endpoint，AccessKeyId，AccessKeySecret这些信息，是以咱们的Schema其实等于这些信息的一个结构化。

这个接口的界说咱们放在provider.go这个文献中终了，以下是这个文献的部分代码。

// Ensure the implementation satisfies the expected interfaces.var ( _ provider.Provider = &ZyunDbProvider{})// New is a helper function to simplify provider server and testing implementation.func New(version string) func() provider.Provider { return func() provider.Provider { return &ZyunDbProvider{ version: version， } }}// ZyunDbProvider defines the provider implementation.type ZyunDbProvider struct { // version is set to the provider version on release， "dev" when the // provider is built and ran locally， and "test" when running acceptance // testing. version string}// Metadata returns the provider type name.func (p *ZyunDbProvider) Metadata(ctx context.Context， req provider.MetadataRequest， resp *provider.MetadataResponse) { resp.TypeName = "zyundb" resp.Version = p.version}// Schema defines the provider-level schema for configuration data.func (p *ZyunDbProvider) Schema(ctx context.Context， req provider.SchemaRequest， resp *provider.SchemaResponse) { resp.Schema = schema.Schema{ Attributes: map[string]schema.Attribute{ "endpoint": schema.StringAttribute{ Description: "The endpoint of the ZyunDB API"， Required: true， }， "access_key_id": schema.StringAttribute{ Description: "The access key id of the ZyunDB API"， Required: true， }， "access_key_secret": schema.StringAttribute{ Description: "The access key secret of the ZyunDB API"， Required: true， Sensitive: true， }， }， }}// Configure prepares a ZyunDB API client for data sources and resources.func (p *ZyunDbProvider) Configure(ctx context.Context， req provider.ConfigureRequest， resp *provider.ConfigureResponse) { // Retrieve provider data from configuration var config zyundbProviderModel diags := req.Config.Get(ctx， &config) resp.Diagnostics.Append(diags...) if resp.Diagnostics.HasError() { return } // If practitioner provided a configuration value for any of the // attributes， it must be a known value. if config.Endpoint.IsUnknown() { resp.Diagnostics.AddAttributeError( path.Root("endpoint")， "Unknown ZyunDB API Host"， "The provider cannot create the ZyunDB API client as there is an unknown configuration value for the ZyunDB API host. "+ "Either target apply the source of the value first， set the value statically in the configuration， or use the ZYUNDB_HOST environment variable."， ) } //........................... if resp.Diagnostics.HasError() { return } // Default values to environment variables， but override // with Terraform configuration value if set. endpoint := os.Getenv("ZYUNDB_ENDPOINT") if !config.Endpoint.IsNull() { endpoint = config.Endpoint.ValueString() } // If any of the expected configurations are missing， return // errors with provider-specific guidance. if endpoint == "" { resp.Diagnostics.AddAttributeError( path.Root("endpoint")， "Missing ZyunDB API Endpoint"， "The provider cannot create the ZyunDB API client as there is a missing or empty value for the ZyunDB API endpoint. "+ "Set the endpoint value in the configuration or use the ZYUNDB_ENDPOINT environment variable. "+ "If either is already set， ensure the value is not empty."， ) } //................................ if resp.Diagnostics.HasError() { return } // Create a new ZyunDB client using the configuration values client := client.NewZyunOpenApiClient(endpoint， accessKeyId， accessKeySecret， "v1"， "https") if client == nil { resp.Diagnostics.AddError( "Unable to Create ZyunDB API Client"， "An unexpected error occurred when creating the ZyunDB API client. "+ "If the error is not clear， please contact the provider developers."， ) return } // Make the ZyunDB client available during DataSource and Resource // type Configure methods. resp.DataSourceData = client resp.ResourceData = client tflog.Info(ctx， "Configured ZyunDB client end")}// Resources defines the resources implemented in the provider.func (p *ZyunDbProvider) Resources(ctx context.Context) []func() resource.Resource { return []func() resource.Resource{ NewMysqlInstanceResource， }}// DataSources defines the data sources implemented in the provider.func (p *ZyunDbProvider) DataSources(_ context.Context) []func() datasource.DataSource { return []func() datasource.DataSource{ NewMysqlInstanceDataSource， }}

其中tflog是Terraform提供的一个日记库，赞理咱们打印日记。

Schema设施中对于每个字段皆界说了Required: true是因为这些字段皆是咱们调用智汇云OpenAPI不成或缺的，而Sensitive: true则代表了这个字段是敏锐字段，包含敏锐信息，例如密码、密钥或其他不应显现在日记或 Terraform 情景文献中的数据。

Configure设施，咱们如果从设立文献中莫得找到对应设立，就会从环境变量中进行寻找。通过找到的这些凭据信息，咱们new了一个ZyunClient，这里因为咱们是一个demo，是以统统这个词client设施是我方在Provider的名目中终了的。一般如果是出产名目，更保举将API部分的细节概述成一个我方的SDK。

而Resources和DataSources设施，复返了后续咱们需要界说的两种资源。

如上，咱们的provider部分的结构就联想完成了，让咱们链接下一步。

3. resource结构联想

当先，咱们看下官方的SDK中对于resource的接口界说：

type Resource interface { // Metadata should return the full name of the resource， such as // examplecloud_thing. Metadata(context.Context， MetadataRequest， *MetadataResponse) // Schema should return the schema for this resource. Schema(context.Context， SchemaRequest， *SchemaResponse) // Create is called when the provider must create a new resource. Config // and planned state values should be read from the // CreateRequest and new state values set on the CreateResponse. Create(context.Context， CreateRequest， *CreateResponse) // Read is called when the provider must read resource values in order // to update state. Planned state values should be read from the // ReadRequest and new state values set on the ReadResponse. Read(context.Context， ReadRequest， *ReadResponse) // Update is called to update the state of the resource. Config， planned // state， and prior state values should be read from the // UpdateRequest and new state values set on the UpdateResponse. Update(context.Context， UpdateRequest， *UpdateResponse) // Delete is called when the provider must delete the resource. Config // values may be read from the DeleteRequest. // // If execution completes without error， the framework will automatically // call DeleteResponse.State.RemoveResource()， so it can be omitted // from provider logic. Delete(context.Context， DeleteRequest， *DeleteResponse)}

不错看到，如果咱们需要终了这个接口，需要终了Metadata，Schema，Create，Read，Update，Delete这几个设施。

Metadata 设施用于提供现时资源的元数据信息，标记资源的独一称号（资源类型名）。

Schema界说了资源的统统属性终点类型。

Create，Read，Update，Delete就无用说了，对应了资源的增改变查。

看了这些，好像有个问题啊，我上头界说的provider的一些设立，能让我网络到API的那些设立，奈何取到呢？这就波及到另一个接口—ResourceWithConfigure接口了，让咱们看下这个接口的界说：

type ResourceWithConfigure interface { Resource // Configure enables provider-level data or clients to be set in the // provider-defined Resource type. It is separately executed for each // ReadResource RPC. Configure(context.Context， ConfigureRequest， *ConfigureResponse)}

终了这个接口就不错允许资源在脱手化时接受来自 Provider 的全局设立（如认证信息、客户端实例、区域诞生等）了。

好了，让咱们脱手开拓这个resource的终了吧。

第一步，咱们依然是需要念念考下咱们的Schema奈何终了。在API模式下，一个资源的各式操作对应的参数不一定是一致的，比如咱们创建了一个自动分拨端口的MySQL实例，创建的接口没传过port，但是取得数据的时辰port就有了；咱们创建的时辰莫得传过一个MySQL实例应该有几个从节点，但是扩容实例的时辰却需要指明在哪个机房扩容几个节点。而对于IaC来说，因为代码就意味着你的资源，你的代码改了，那么你的资源就会更新，这种情况下咱们就需要将统统的这些API的入参出参进行接洽，将统统这个词Schema行为你的资源的举座。

咱们先看下创建一个MySQL的入参：

再看下设立变更的入参，不错发现extendInfos澈底是个迥殊的参数，根蒂与创建实例和底下的实例细目没相联系，但是咱们却需要终了举座实例的节点扩容：

以及MySQL实例细宗旨复返值，根据如下复返值，咱们其实不错意料，将master和slave的复返信息进行一定的处理就不错行为参数传给设立变更的API了：

{ "status" : 200， "developer-message" : ""， "more-info" : ""， "errno-code" : 0， "user-message" : ""， "data" : { "id" : "xxx"， "port" : "xxx"， "status" : "1"， "ctime" : "2024-09-23 19:42:39"， "utime" : "2024-09-23 19:52:13"， "pkg_id" : "xxx"， "db_type" : "master-slave"， "is_audit" : "1"， "name" : "test_name"， "instance_type" : "EXCLUSIVE"， "network_id" : "xxx"， "subnet_id" : "xxx"， "idc" : [ "xxidc" ]， "rs_num" : [ { "cnt" : "2"， "idc" : "xxidc" } ]， "master" : [ { "ip" : "1.1.1.1"， "idc" : "xxidc"， "type" : "master"， "idc_name" : "北京A区" } ]， "slave" : [ { "ip" : "2.2.2.2"， "idc" : "xxidc"， "type" : "slave"， "idc_name" : "北京A区" } ]， "vip_data" : [ { "port" : "xxx"， "idc" : "xxidc"， "vip" : "3.3.3.3"， "rw_status" : "6"， "idc_name" : "北京A区" } ]， }}

根据以上信息，咱们暂为Schema界说为如下结构：

type mysqlInstanceResourceModel struct { ID types.String `tfsdk:"id"` ProjectID types.String `tfsdk:"project_id"` Port types.String `tfsdk:"port"` Name types.String `tfsdk:"name"` PkgID types.String `tfsdk:"pkg_id"` InstanceType types.String `tfsdk:"instance_type"` Mode types.String `tfsdk:"mode"` MasterIDC types.String `tfsdk:"master_idc"` RedundantIDC types.String `tfsdk:"redundant_idc"` NetworkID types.String `tfsdk:"network_id"` SubnetID types.String `tfsdk:"subnet_id"` IsAuditLog types.String `tfsdk:"is_audit_log"` Status types.String `tfsdk:"status"` CTime types.String `tfsdk:"ctime"` VipData types.List `tfsdk:"vip_data"` MasterNum types.List `tfsdk:"master_num"` SlaveNum types.List `tfsdk:"slave_num"` Timeouts timeouts.Value `tfsdk:"timeouts"`}

其中大部分参数咱们皆是根据创建实例设施来的，而VipData以及MasterNum和SlaveNum则主要方便后续给用户展示网络格式以及方便用户进行设立变更。

咱们将这个resource的界说文献定名为mysql_instance_resource.go，部分代码如下：

// Ensure the implementation satisfies the expected interfaces.var ( _ resource.Resource = &mysqlInstanceResource{} _ resource.ResourceWithConfigure = &mysqlInstanceResource{})// NewMysqlInstanceResource is a helper function to simplify the provider implementation.func NewMysqlInstanceResource() resource.Resource { return &mysqlInstanceResource{}}// mysqlInstanceResource is the resource implementation.type mysqlInstanceResource struct { client *client.ZyunOpenAPI}// mysqlInstanceResourceModel maps the resource schema data.type mysqlInstanceResourceModel struct {// .........}// Metadata returns the resource type name.func (r *mysqlInstanceResource) Metadata(_ context.Context， req resource.MetadataRequest， resp *resource.MetadataResponse) { resp.TypeName = req.ProviderTypeName + "_mysql_instance"}// Schema defines the schema for the resource.func (r *mysqlInstanceResource) Schema(ctx context.Context， _ resource.SchemaRequest， resp *resource.SchemaResponse) { resp.Schema = schema.Schema{ Attributes: map[string]schema.Attribute{ "timeouts": timeouts.Attributes(ctx， timeouts.Opts{ Create: true， })， "id": schema.StringAttribute{ Description: "The id of the mysql instance"， Computed: true， PlanModifiers: []planmodifier.String{ stringplanmodifier.UseStateForUnknown()， }， }， "port": schema.StringAttribute{ Description: "The port of the mysql instance"， Computed: true， PlanModifiers: []planmodifier.String{ stringplanmodifier.UseStateForUnknown()， stringplanmodifier.RequiresReplace()， }， }， "network_id": schema.StringAttribute{ Description: "The network id of the mysql instance"， Required: true， }， "vip_data": schema.ListNestedAttribute{ Description: "The vip data of the mysql instance"， Computed: true， NestedObject: schema.NestedAttributeObject{ Attributes: map[string]schema.Attribute{ "vip": schema.StringAttribute{ Description: "The vip of the vip"， Computed: true， }， //..................... }， }， }， //........................ }， }}// Configure adds the provider configured client to the resource.func (r *mysqlInstanceResource) Configure(_ context.Context， req resource.ConfigureRequest， resp *resource.ConfigureResponse) { // Add a nil check when handling ProviderData because Terraform // sets that data after it calls the ConfigureProvider RPC. if req.ProviderData == nil { return } client， ok := req.ProviderData.(*client.ZyunOpenAPI) if !ok { resp.Diagnostics.AddError( "Unexpected Data Source Configure Type"， fmt.Sprintf("Expected *client.ZyunOpenAPI， got: %T. Please report this issue to the provider developers."， req.ProviderData)， ) return } r.client = client}// Create creates the resource and sets the initial Terraform state.func (r *mysqlInstanceResource) Create(ctx context.Context， req resource.CreateRequest， resp *resource.CreateResponse) { var plan mysqlInstanceResourceModel diags := req.Plan.Get(ctx， &plan) resp.Diagnostics.Append(diags...) if resp.Diagnostics.HasError() { return } // 取得超时高下文 createTimeout， diags := plan.Timeouts.Create(ctx， 20*time.Minute) resp.Diagnostics.Append(diags...) if resp.Diagnostics.HasError() { return } ctx， cancel := context.WithTimeout(ctx， createTimeout) defer cancel() // Generate API request body from plan // Create new mysql instance result， err := r.client.CreateMySQLInstance(ctx， &client.CreateMySQLInstanceParams{ ProjectID: plan.ProjectID.ValueString()， //................ }) if err != nil { resp.Diagnostics.AddError( "Error creating mysql instance"， "Could not create mysql instance， unexpected error: "+err.Error()， ) return } instanceID := result.Detail.InsID plan.ID = types.StringValue(instanceID) // Poll to check the instance status ticker := time.NewTicker(10 * time.Second) defer ticker.Stop()CheckLoop: for { select { case <-ctx.Done(): resp.Diagnostics.AddError( "Timeout waiting for MySQL instance creation"， fmt.Sprintf("Instance %s creation did not complete within the timeout period"， instanceID)， ) return case <-ticker.C: instance， err := r.client.GetMySQLInstance(ctx， plan.ProjectID.ValueString()， instanceID) if err != nil { continue } // Status 1 means ready if instance.Status == "1" { plan.xx = xx //.......................... break CheckLoop } else if instance.Status == "2" { // 2 means failed resp.Diagnostics.AddError( "Error creating mysql instance"， "MySQL instance creation failed"， ) return } } } diags = resp.State.Set(ctx， plan) resp.Diagnostics.Append(diags...)}// Read refreshes the Terraform state with the latest data.func (r *mysqlInstanceResource) Read(ctx context.Context， req resource.ReadRequest， resp *resource.ReadResponse) { // Get current state //.............. // Get refreshed order value from HashiCups instance， err := r.client.GetMySQLInstance(ctx， state.ProjectID.ValueString()， state.ID.ValueString()) if err != nil { resp.Diagnostics.AddError( "Error Reading mysql instance"， "Could not read mysql instance ID "+state.ID.ValueString()+": "+err.Error()， ) return } //................................ // Set refreshed state diags = resp.State.Set(ctx， &state) resp.Diagnostics.Append(diags...)}// Update updates the resource and sets the updated Terraform state on success.func (r *mysqlInstanceResource) Update(ctx context.Context， req resource.UpdateRequest， resp *resource.UpdateResponse) { // 处理更新值到params................ err := r.client.UpdateMySQLInstance(ctx， params) if err != nil { //............ return } resp.Diagnostics.AddWarning( "Asynchronous Operation"， "The MySQL instance update is an asynchronous operation. Use 'terraform refresh' to get the latest state after the update completes."， ) diags = resp.State.Set(ctx， plan) resp.Diagnostics.Append(diags...) if resp.Diagnostics.HasError() { return }}// Delete deletes the resource and removes the Terraform state on success.func (r *mysqlInstanceResource) Delete(ctx context.Context， req resource.DeleteRequest， resp *resource.DeleteResponse) { // Retrieve values from state // .......... // Delete existing mysql instance err := r.client.DeleteMySQLInstance(ctx， state.ProjectID.ValueString()， state.ID.ValueString()) if err != nil { resp.Diagnostics.AddError( "Error Deleting mysql instance"， "Could not delete mysql instance， unexpected error: "+err.Error()， ) return }}

以上代码中有几个需要严防的部分：

1.在schema的界说中，咱们使用了Computed: true，和Optional: true这两个上文还未出现过的属性，其中Computed:true是默示此属性的值由提供者（Provider）磋商并填充，而不是用户成功提供，也等于雷同于自动生成的实例ID之类的。而Optional:true默示此属性是可选的，用户不错采选是否在 Terraform 设立文献中诞生该值。

2.stringplanmodifier.UseStateForUnknown()以及stringplanmodifier.RequiresReplace()。

其中UseStateForUnknown默示当 Terraform 无法确定一个属性的新值（即该值是未知的，unknown），此修饰器会指引 Terraform 在联想阶段使用现时情景（state）中的值行为暂时的联想值。适用于在资源人命周期中，新值可能暂时不成用，但现存值不错行为替代。例如，某些属性的值需要依赖外部磋商着力（如而已 API 的反应），但这着力在联想阶段尚未可知。

RequiresReplace默示如果该属性的值在设立中发生革新，则需要死心并再行创建统统这个词资源（触发替换操作）。这个使用场景如故相比常见的，因为好多咱们创建时辰救援的属性，可能在更新时辰咱们并不救援更新，那么诞生了这个修饰器，Terraform就会自动为咱们处理删除并再行创建的进程。

3.Create中的轮询处理

大部分情况下，咱们的资源可能并不是瞬时创建完成，况且接口自己是个异步接口。这个时辰不错进行轮询处理并指定超频频间，以便最终资源的属性不错回填。此处咱们是通过ticker阿谀Terraform的超时高下文部分来处理的（严防schema的界说要有timeouts属性，而最终的超频频间不错让使用者在资源的使用设立中界说）：

// 取得超时高下文 createTimeout， diags := plan.Timeouts.Create(ctx， 20*time.Minute) resp.Diagnostics.Append(diags...) if resp.Diagnostics.HasError() { return } ctx， cancel := context.WithTimeout(ctx， createTimeout) defer cancel()

4.Update的异步但不处理数据回填

此处咱们的Update设施其实亦然个异步设施，但是咱们莫得添加轮询来进行数据的回填，相对的，咱们通过增多了一个Warning来见告用户我方去刷新数据：

resp.Diagnostics.AddWarning( "Asynchronous Operation"， "The MySQL instance update is an asynchronous operation. Use 'terraform refresh' to get the latest state after the update completes."， )

以上等于resource部分的终了，不错看出，举座终了格式如故相配方便的，通过Get从Context中取得到设立文献确现时数据，再通过Set将从接口中拉取到的数据回填。

5. data结构联想

咱们看下终末一种资源的结构联想，当先如故先看下官方的接口界说：

type DataSource interface { // Metadata should return the full name of the data source， such as // examplecloud_thing. Metadata(context.Context， MetadataRequest， *MetadataResponse) // Schema should return the schema for this data source. Schema(context.Context， SchemaRequest， *SchemaResponse) // Read is called when the provider must read data source values in // order to update state. Config values should be read from the // ReadRequest and new state values set on the ReadResponse. Read(context.Context， ReadRequest， *ReadResponse)}

不错看到，举座接口跟之前皆差未几，只不外唯有最浅薄的Read设施需要终赫然，其余人命周期是莫得的。相同，咱们也需要终了DataSourceWithConfigure好能够索要之前provider的设立。

type DataSourceWithConfigure interface { DataSource // Configure enables provider-level data or clients to be set in the // provider-defined DataSource type. It is separately executed for each // ReadDataSource RPC. Configure(context.Context， ConfigureRequest， *ConfigureResponse)}

这里的代码就不赘述了，独一需要严防的部分是在resource的联想中，咱们不错看到，比如VipData，咱们界说的类型是types.List，是以咱们需要在具体的CRUD中写更多的代码去向理type.List到其履行结构的处理。而其实，对于data类型的资源，咱们就不错成功使用原始的go切片了。这是为什么呢？原因是resource类型的资源，咱们在Create的进程中，想要去使用VipData这个数据，这个时辰Terraform需要对其进行暴露，如果是go的原始切片，就失去了Terraform对对应类型的一些荫藏处理，同期在履行terraform敕令的时辰就会报错。而data资源就莫得这个费心了。

6. 进口文献

终末看一下进口文献的代码吧

var ( // these will be set by the goreleaser configuration // to appropriate values for the compiled binary. version string = "dev" // goreleaser can pass other information to the main package， such as the specific commit // https://goreleaser.com/cookbooks/using-main.version/)func main() { var debug bool flag.BoolVar(&debug， "debug"， false， "set to true to run the provider with support for debuggers like delve") flag.Parse() opts := providerserver.ServeOpts{ // TODO: Update this string with the published name of your provider. // Also update the tfplugindocs generate command to either remove the // -provider-name flag or set its value to the updated provider name. Address: "local/namespace/zyundb"， Debug: debug， } err := providerserver.Serve(context.Background()， provider.New(version)， opts) if err != nil { log.Fatal(err.Error()) }}

这里主要需要严防的是Address，如果是仍是发布的provider，不错换成对应的域名以及对应的定名空间，因为咱们这里是腹地环境，是以暂时用local代替。

7.终了单位测试

天然，也别忘了书写单位测试，这里用一个相比浅薄的单位测试行为示例，具体不错看对应测试包的终了：

func TestAccMysqlInstanceDataSource(t *testing.T) { resource.Test(t， resource.TestCase{ ProtoV6ProviderFactories: testAccProtoV6ProviderFactories， Steps: []resource.TestStep{ // Read testing { Config: providerConfig + `data "zyundb_mysql_instance" "all" { project_id = "xxxx"}`， Check: resource.ComposeAggregateTestCheckFunc( // Verify number of coffees returned resource.TestCheckResourceAttrSet("data.zyundb_mysql_instance.all"， "mysql_instance.#")， // Verify the first coffee to ensure all attributes are set resource.TestCheckResourceAttrSet("data.zyundb_mysql_instance.all"， "mysql_instance.0.id")， resource.TestCheckResourceAttrSet("data.zyundb_mysql_instance.all"， "mysql_instance.0.name")， resource.TestCheckResourceAttrSet("data.zyundb_mysql_instance.all"， "mysql_instance.0.port")， )， }， }， })}

然后履行一下吧：

TF_LOG=ERROR TF_ACC=1 go test -count=1 -run='TestAccMysqlInstanceDataSource' -v

输出：

=== RUN TestAccMysqlInstanceDataSource--- PASS: TestAccMysqlInstanceDataSource (2.66s)PASSok terraform-provider-zyundb/internal/provider 3.574s

3、腹地使用我方的Provider

既然咱们仍是终赫然我方的Provider，那就来使用一下吧。当先咱们先了解下Terraform的使命流：

其实举座来说等于先履行terraform init脱手化环境，然后履行terraform plan看下terraform接下来会作念什么改变，终末履行terraform apply来行使这个变更。

因为咱们使用的是腹地的Provider，是以咱们当先需要先剪辑Terraform CLI设立文献来让其能够发现咱们腹地的Provider，一般这个文献在~/.terraformrc，怒放并修改它：

provider_installation { dev_overrides { "local/namespace/zyundb" = "/Users/xxx/terraform-providers" } # For all other providers， install them directly from their origin provider # registries as normal. If you omit this， Terraform will _only_ use # the dev_overrides block， and so no other providers will be available. direct {}}

这里要严防local/namespace/zyundb部分要跟咱们之前在进口文献里界说的保握一致，而/Users/xxx/terraform-providers等于咱们终末用来放二进制文献的处所，这个目次是不错我方璷黫界说的，只消这个目次下有你终末的Provider的二进制文献。

编译

GOOS=darwin GOARCH=amd64 go build -o terraform-provider-zyundb_v1.0.0

然后将编译好的二进制文献放到上头的目次下。

设立并测试

创建一个main.tf，并剪辑如下：

# Copyright (c) HashiCorp， Inc.terraform { required_providers { zyundb = { source = "local/namespace/zyundb" version = "1.0.0" } }}provider "zyundb" { endpoint = "你的endpoint" access_key_id = "你的access key" access_key_secret = "你的access key secret"}data "zyundb_mysql_instance" "all" { project_id = "你的资源组ID"}output "mysql_instance" { value = data.zyundb_mysql_instance.all}resource "zyundb_mysql_instance" "example" { name = "example" project_id = "你的资源组ID" pkg_id = "套餐ID" instance_type = "NORMAL" mode = "master-slave" master_idc = "xxidc" redundant_idc = "" network_id = "xxx" subnet_id = "xxx" is_audit_log = true timeouts = { create = "60m" }}

然后，履行terraform init吗？不，如果是使用腹地的terraform provider，请不要履行这一步，这是为什么呢？

因为terraform init 是用来脱手化 Terraform 设立的，它时时会下载所需的而已提供者并脱手化情景。但是，当你使用腹地开拓的提供者时，terraform init 并不会像平常那样从而已注册表下载提供者，因为腹地提供者仍是通过 dev_overrides 设立指定。因此，Terraform 不需要再运行 terraform init 来取得而已提供者。

如果你依然履行了 terraform init，它可能会尝试下载而已提供者，况且在你腹地提供者存在的情况下，可能会激励一些诞妄或打破。

比如:

是以，履行terraform plan吧

这个时辰它就会列出会发生的变更。如果莫得发现问题，那么履行terraform apply行使就不错了。

不错看到在apply的过程中咱们的轮询日记亦然会打印出来的：

天然，plan或者apply皆有可能会失败，这个时辰不错在敕令前增多TF_LOG=debug/trace等就不错查看详备的报错信息了。

4、生成文档

如果是一个需要发布的Provider，文档如故很有必要的，而Terraform为咱们提供了很方便的格式去生成文档。还记起咱们代码中加的那些Description吗？那些等于生成文档的必须。

在仍是添加了Description的前提下，咱们在名目下再新建一个目次examples，鄙人面写下各式示例的tf文献，然后新建一个tools目次，新建tools.go，如下：

//go:build generatepackage toolsimport ( _ "github.com/hashicorp/copywrite" _ "github.com/hashicorp/terraform-plugin-docs/cmd/tfplugindocs")// Generate copyright headers//go:generate go run github.com/hashicorp/copywrite headers -d .. --config ../.copywrite.hcl// Format Terraform code for use in documentation.// If you do not have Terraform installed， you can remove the formatting command， but it is suggested// to ensure the documentation is formatted properly.//go:generate terraform fmt -recursive ../examples/// Generate documentation.//go:generate go run github.com/hashicorp/terraform-plugin-docs/cmd/tfplugindocs generate --provider-dir .. -provider-name zyundb

严防provider-name若是对应上的。

然后cd tools; go generate ./…不错看到输出如下

然后，文档就生成了。

终末，看下举座的目次结构吧：

.├── README.md├── docs //这部分目次下皆是自动生成的文档│ ├── sources│ │ └── mysql_instance.md│ ├── i成人游戏下载

上一篇：成人游戏下载 突发! 马斯克受军方审查    下一篇：成人游戏下载 股票行情快报：中集环科（301559）12月19日主力资金净卖出85.95万元