阅读本文，您可以获取 Go SDK 域名管理的接口调用示例，实现快速开发。

调用说明

• 本文提供的接口调用示例均通过 AK 和 SK 初始化实例。
• 接口的参数说明和错误码等信息可通过接口文档查看。

前提条件

调用接口前，请先完成 Go SDK 的安装及初始化操作。

调用示例

本节为您介绍域名管理相关接口的功能和调用示例。

新增域名

您可以调用 AddDomainV1 接口新增域名。详细的参数说明可参见 AddDomainV1 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_AddDomainV1(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.AddDomainV1Req{
      AddDomainV1Query: &imagex.AddDomainV1Query{},
      AddDomainV1Body:  &imagex.AddDomainV1Body{},
   }

   resp, err := instance.AddDomainV1(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

删除域名

您可以调用 DelDomain 接口删除指定域名。详细的参数说明可参见 DelDomain 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_DelDomain(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.DelDomainReq{
      DelDomainQuery: &imagex.DelDomainQuery{},
      DelDomainBody:  &imagex.DelDomainBody{},
   }

   resp, err := instance.DelDomain(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新域名配置

您可以调用 UpdateImageDomainConfig 接口更新域名配置。详细的参数说明可参见 UpdateImageDomainConfig 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_UpdateImageDomainConfig(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.UpdateImageDomainConfigReq{
      UpdateImageDomainConfigQuery: &imagex.UpdateImageDomainConfigQuery{},
      UpdateImageDomainConfigBody:  &imagex.UpdateImageDomainConfigBody{},
   }

   resp, err := instance.UpdateImageDomainConfig(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新响应头配置

您可以调用 UpdateResponseHeader 接口更新响应头配置。详细的参数说明可参见 UpdateResponseHeader 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_UpdateResponseHeader(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.UpdateResponseHeaderReq{
      UpdateResponseHeaderQuery: &imagex.UpdateResponseHeaderQuery{},
      UpdateResponseHeaderBody:  &imagex.UpdateResponseHeaderBody{},
   }

   resp, err := instance.UpdateResponseHeader(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新默认域名配置

您可以调用 SetDefaultDomain 接口更新默认域名配置。详细的参数说明可参见 SetDefaultDomain 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_SetDefaultDomain(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.SetDefaultDomainBody{}

   resp, err := instance.SetDefaultDomain(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新 Referer 防盗链配置

您可以调用 UpdateRefer 接口更新 Referer 防盗链配置。详细的参数说明可参见 UpdateRefer 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_UpdateRefer(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.UpdateReferReq{
      UpdateReferQuery: &imagex.UpdateReferQuery{},
      UpdateReferBody:  &imagex.UpdateReferBody{},
   }

   resp, err := instance.UpdateRefer(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新 https 配置

您可以调用 UpdateHttps 接口更新 https 配置。详细的参数说明可参见 UpdateHttps 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_UpdateHTTPS(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.UpdateHTTPSReq{
      UpdateHTTPSQuery: &imagex.UpdateHTTPSQuery{},
      UpdateHTTPSBody:  &imagex.UpdateHTTPSBody{},
   }

   resp, err := instance.UpdateHTTPS(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新 IP 黑白名单配置

您可以调用 UpdateImageDomainIPAuth 接口更新 IP 黑白名单配置。详细的参数说明可参见 UpdateImageDomainIPAuth 接口文档。
接口调用示例如下所示。

package imagex_test


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


    "github.com/volcengine/volc-sdk-golang/base"
    imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)


func Test_UpdateImageDomainIPAuth(t *testing.T) {
    instance := imagex.NewInstance()


    instance.SetCredential(base.Credentials{
        AccessKeyID:     "ak",
        SecretAccessKey: "sk",
    })


    param := &imagex.UpdateImageDomainIPAuthReq{
        UpdateImageDomainIPAuthQuery: &imagex.UpdateImageDomainIPAuthQuery{},
        UpdateImageDomainIPAuthBody:  &imagex.UpdateImageDomainIPAuthBody{},
    }


    resp, err := instance.UpdateImageDomainIPAuth(context.Background(), param)


    if err != nil {
        fmt.Printf("error %v", err)
    } else {
        t, _ := json.Marshal(resp)
        fmt.Printf("success %v", string(t))
    }
}

更新 UA 黑白名单配置

您可以调用 UpdateImageDomainUaAccess 接口更新 UA 黑白名单配置。详细的参数说明可参见 UpdateImageDomainUaAccess 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_UpdateImageDomainUaAccess(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.UpdateImageDomainUaAccessReq{
      UpdateImageDomainUaAccessQuery: &imagex.UpdateImageDomainUaAccessQuery{},
      UpdateImageDomainUaAccessBody:  &imagex.UpdateImageDomainUaAccessBody{},
   }

   resp, err := instance.UpdateImageDomainUaAccess(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新地域访问限制配置

您可以调用 UpdateImageDomainAreaAccess 接口更新地域访问限制配置。详细的参数说明可参见 UpdateImageDomainAreaAccess 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_UpdateImageDomainAreaAccess(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.UpdateImageDomainAreaAccessReq{
      UpdateImageDomainAreaAccessQuery: &imagex.UpdateImageDomainAreaAccessQuery{},
      UpdateImageDomainAreaAccessBody:  &imagex.UpdateImageDomainAreaAccessBody{},
   }

   resp, err := instance.UpdateImageDomainAreaAccess(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新域名自适应格式配置

您可以调用 UpdateDomainAdaptiveFmt 接口更新域名自适应格式配置。详细的参数说明可参见 UpdateDomainAdaptiveFmt 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_UpdateDomainAdaptiveFmt(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.UpdateDomainAdaptiveFmtReq{
      UpdateDomainAdaptiveFmtQuery: &imagex.UpdateDomainAdaptiveFmtQuery{},
      UpdateDomainAdaptiveFmtBody:  &imagex.UpdateDomainAdaptiveFmtBody{},
   }

   resp, err := instance.UpdateDomainAdaptiveFmt(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新集智瘦身配置

您可以调用 UpdateSlimConfig 接口更新集智瘦身配置。详细的参数说明可参见 UpdateSlimConfig 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_UpdateSlimConfig(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.UpdateSlimConfigReq{
      UpdateSlimConfigQuery: &imagex.UpdateSlimConfigQuery{},
      UpdateSlimConfigBody:  &imagex.UpdateSlimConfigBody{},
   }

   resp, err := instance.UpdateSlimConfig(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新域名高级配置

您可以调用 UpdateAdvance 接口更新域名高级配置。详细的参数说明可参见 UpdateAdvance 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_UpdateAdvance(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.UpdateAdvanceReq{
      UpdateAdvanceQuery: &imagex.UpdateAdvanceQuery{},
      UpdateAdvanceBody:  &imagex.UpdateAdvanceBody{},
   }

   resp, err := instance.UpdateAdvance(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新带宽限制配置

您可以调用 UpdateImageDomainBandwidthLimit 接口更新带宽限制配置。详细的参数说明可参见 UpdateImageDomainBandwidthLimit 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_UpdateImageDomainBandwidthLimit(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.UpdateImageDomainBandwidthLimitReq{
      UpdateImageDomainBandwidthLimitQuery: &imagex.UpdateImageDomainBandwidthLimitQuery{},
      UpdateImageDomainBandwidthLimitBody:  &imagex.UpdateImageDomainBandwidthLimitBody{},
   }

   resp, err := instance.UpdateImageDomainBandwidthLimit(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

更新下载限速配置

您可以调用 UpdateImageDomainDownloadSpeedLimit 接口更新下载限速配置。详细的参数说明可参见 UpdateImageDomainDownloadSpeedLimit 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_UpdateImageDomainDownloadSpeedLimit(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.UpdateImageDomainDownloadSpeedLimitReq{
      UpdateImageDomainDownloadSpeedLimitQuery: &imagex.UpdateImageDomainDownloadSpeedLimitQuery{},
      UpdateImageDomainDownloadSpeedLimitBody:  &imagex.UpdateImageDomainDownloadSpeedLimitBody{},
   }

   resp, err := instance.UpdateImageDomainDownloadSpeedLimit(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

获取域名配置

您可以调用 GetDomainConfig 接口获取域名配置。详细的参数说明可参见 GetDomainConfig 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_GetDomainConfig(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.GetDomainConfigQuery{}

   resp, err := instance.GetDomainConfig(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

获取服务下全部域名

您可以调用 GetServiceDomains 接口获取服务下全部域名。详细的参数说明可参见 GetServiceDomains 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_GetServiceDomains(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   param := &imagex.GetServiceDomainsQuery{}

   resp, err := instance.GetServiceDomains(context.Background(), param)

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

获取响应头允许的 key 列表

您可以调用 GetResponseHeaderValidateKeys 接口获取当前账号全部合法的响应头 key 信息。详细的参数说明可参见 GetResponseHeaderValidateKeys 接口文档。
接口调用示例如下所示。

package imagex_test

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

   "github.com/volcengine/volc-sdk-golang/base"
   imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_GetResponseHeaderValidateKeys(t *testing.T) {
   instance := imagex.NewInstance()

   instance.SetCredential(base.Credentials{
      AccessKeyID:     "ak",
      SecretAccessKey: "sk",
   })

   resp, err := instance.GetResponseHeaderValidateKeys(context.Background())

   if err != nil {
      fmt.Printf("error %v", err)
   } else {
      t, _ := json.Marshal(resp)
      fmt.Printf("success %v", string(t))
   }
}

获取域名归属权校验内容

您可以调用 GetDomainOwnerVerifyContent 接口获取域名归属权校验内容。详细的参数说明可参见 GetDomainOwnerVerifyContent 接口文档。
接口调用示例如下所示。

package imagex_test

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

        "github.com/volcengine/volc-sdk-golang/base"
        imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_GetDomainOwnerVerifyContent(t *testing.T) {
        instance := imagex.NewInstance()

        instance.SetCredential(base.Credentials{
                AccessKeyID:     "ak",
                SecretAccessKey: "sk",
        })

        param := &imagex.GetDomainOwnerVerifyContentQuery{}

        resp, err := instance.GetDomainOwnerVerifyContent(context.Background(), param)

        if err != nil {
                fmt.Printf("error %v", err)
        } else {
                t, _ := json.Marshal(resp)
                fmt.Printf("success %v", string(t))
        }
}

校验域名归属权

您可以调用 VerifyDomainOwner 接口获取域名归属权校验内容。详细的参数说明可参见 VerifyDomainOwner 接口文档。
接口调用示例如下所示。

package imagex_test

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

        "github.com/volcengine/volc-sdk-golang/base"
        imagex "github.com/volcengine/volc-sdk-golang/service/imagex/v2"
)

func Test_VerifyDomainOwner(t *testing.T) {
        instance := imagex.NewInstance()

        instance.SetCredential(base.Credentials{
                AccessKeyID:     "ak",
                SecretAccessKey: "sk",
        })

        param := &imagex.VerifyDomainOwnerReq{
                VerifyDomainOwnerQuery: &imagex.VerifyDomainOwnerQuery{},
                VerifyDomainOwnerBody:  &imagex.VerifyDomainOwnerBody{},
        }

        resp, err := instance.VerifyDomainOwner(context.Background(), param)

        if err != nil {
                fmt.Printf("error %v", err)
        } else {
                t, _ := json.Marshal(resp)
                fmt.Printf("success %v", string(t))
        }
}