jenkins Job华为云EIP变更带宽-Toy模板网

这篇具有很好参考价值的文章主要介绍了jenkins Job华为云EIP变更带宽。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

引言:

在数字化时代，云服务资源的弹性管理是企业降低运营成本、提高效率的关键手段。通过弹性公网IP（EIP）服务，企业可以实现按需计费，优化网络支出。然而，根据业务流量的不同阶段调整计费模式，则是提升成本效益的进阶策略。本人腾讯云快十年老用户乘机吐槽一下腾讯云（由于我在大有所为的某云上面已经简单实现了更改流程）：
习惯了使用apiexplorer这样的工具生成代码进行修改，参考一下友商的：
jenkins Job华为云EIP变更带宽,jenkins,linux工具,华为云,jenkins,华为云,devops,运维开发
然后我的腾讯云弹性公网IP ?EIP 对吧？

这是什么样的体验？完全搜索不到？关键词EIP **弹性公网 **完全搜索不到…

最后我在这里找到了：
绑定弹性公网IP
jenkins Job华为云EIP变更带宽,jenkins,linux工具,华为云,jenkins,华为云,devops,运维开发
你可以归于私有网络？是不是应该好歹独立一下…

吐槽完毕，本文将详细介绍如何使用华为云Go SDK在流量高峰时自动调整EIP带宽设置，并在峰值过后恢复原计费模式。

业务背景:

考虑到一家在线互动应用提供商，主要架构是websockt 长链接，其流量在晚高峰时段飙升，观众涌入平台进行抢红包等互动活动。活动时常大概在一个小时。在流量高峰时，固定带宽的使用能保证用户的观看体验，且相对于按流量计费，成本更为可控。因此，我们面临一个机遇，通过智能化工具调整EIP的带宽计费模式，在需要时提供稳定的网络资源和更优的财务开支。

技术方案:

服务器场景搭建在华为云上，使用了cce kubernetes服务。绑定了应用型负载均衡（负载均衡有本身的EIP公网IP），为了实现这一目标，我们选择华为云的Elastic IP服务，它提供了一系列API，允许程序化管理EIP资源。通过Go语言编写的定时任务，我们可以精确控制带宽的调整时机和规模。在本方案中，使用华为云提供的SDK，我们将编写一个Go应用程序，当业务流量达到高峰时，自动将EIP的计费模式从按流量计费调整为按带宽计费，并固定带宽大小。一小时后，系统自动将设置恢复为按流量计费，以节省成本。

代码实现:

参照以下代码实例：UpdateBandwidth 更新带宽方法：
jenkins Job华为云EIP变更带宽,jenkins,linux工具,华为云,jenkins,华为云,devops,运维开发

package main

import (
	"fmt"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
    eip "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/model"
    region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/region"
)

func main() {
    // The AK and SK used for authentication are hard-coded or stored in plaintext, which has great security risks. It is recommended that the AK and SK be stored in ciphertext in configuration files or environment variables and decrypted during use to ensure security.
    // In this example, AK and SK are stored in environment variables for authentication. Before running this example, set environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment
    ak := os.Getenv("CLOUD_SDK_AK")
    sk := os.Getenv("CLOUD_SDK_SK")

    auth := basic.NewCredentialsBuilder().
        WithAk(ak).
        WithSk(sk).
        Build()

    client := eip.NewEipClient(
        eip.EipClientBuilder().
            WithRegion(region.ValueOf("cn-east-3")).
            WithCredential(auth).
            Build())

    request := &model.UpdatePublicipRequest{}
	request.Body = &model.UpdatePublicipsRequestBody{
	}
	response, err := client.UpdatePublicip(request)
	if err == nil {
        fmt.Printf("%+v\n", response)
    } else {
        fmt.Println(err)
    }
}

最终实现代码如下：

package main

import (
	"fmt"
	"time"

	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/config"
	eip "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/model"
	region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/region"
)

func main() {
	// Replace with your own AK/SK, Region, and Project ID.
	ak := "xxxxx"
	sk := "xxxxx"
	projectID := "xxxxx"

	// Authenticate using your Access Key and Secret Key.
	auth := basic.NewCredentialsBuilder().
		WithAk(ak).
		WithSk(sk).
		WithProjectId(projectID).
		Build()

	// Create EIP client configuration.
	eipClient := eip.NewEipClient(
		eip.EipClientBuilder().
			WithRegion(region.ValueOf("cn-east-3")).
			WithCredential(auth).
			WithHttpConfig(config.DefaultHttpConfig()).
			Build(),
	)

	// Replace the bandwidthId with your actual bandwidth ID.
	sizeBandwidth := int32(xxx)
	sizeTraefikBandwidth := int32(xxxx)

	// Update bandwidth to 10 Mbps and set to bandwidth billing mode.
	if err := updateBandwidth(eipClient, bandwidthId, "", sizeBandwidth, model.GetUpdateBandwidthOptionChargeModeEnum().BANDWIDTH); err != nil {
		fmt.Printf("Error updating bandwidth: %s\n", err)
		return
	}
	// Set a timer to switch back to traffic billing mode after 1 hour.
	time.AfterFunc(1*time.Hour, func() {
		if err := updateBandwidth(eipClient, bandwidthId, "", sizeTraefikBandwidth, model.GetUpdateBandwidthOptionChargeModeEnum().TRAFFIC); err != nil {
			fmt.Printf("Error reverting bandwidth: %s\n", err)
			return
		}
	})

	// Block the main goroutine to not exit immediately.
	select {}
}

// Function to update the bandwidth of an EIP.
func updateBandwidth(client *eip.EipClient, bandwidthId, name string, size int32, chargeMode model.UpdateBandwidthOptionChargeMode) error {
	request := &model.UpdateBandwidthRequest{
		BandwidthId: bandwidthId,
		Body: &model.UpdateBandwidthRequestBody{
			Bandwidth: &model.UpdateBandwidthOption{
				Name:       &name,
				Size:       &size,
				ChargeMode: &chargeMode,
			},
		},
	}

	response, err := client.UpdateBandwidth(request)
	if err != nil {
		return err
	}
	fmt.Printf("Update response: %+v\n", response)
	return nil
}

初始化EIP客户端

首先，需设置客户端认证，这涉及到基础的Access Key（AK）和Secret Key（SK）配置：

ak := "REPLACE_WITH_YOUR_AK"
sk := "REPLACE_WITH_YOUR_SK"
projectID := "REPLACE_WITH_YOUR_PROJECT_ID"

    auth := basic.NewCredentialsBuilder().
        WithAk(ak).
        WithSk(sk).
        Build()

    client := eip.NewEipClient(
        eip.EipClientBuilder().
            WithRegion(region.ValueOf("cn-east-3")).
            WithCredential(auth).
            Build())
...

务必保障这些敏感信息在环境变量或加密存储中，避免硬编码在应用程序中。

更新带宽函数

updateBandwidth 函数对EIP带宽大小和计费模式进行修改。

func updateBandwidth(client *eip.EipClient, bandwidthId, name string, size int32, chargeMode model.UpdateBandwidthOptionChargeMode) error {
	request := &model.UpdateBandwidthRequest{
		BandwidthId: bandwidthId,
		Body: &model.UpdateBandwidthRequestBody{
			Bandwidth: &model.UpdateBandwidthOption{
				Name:       &name,
				Size:       &size,
				ChargeMode: &chargeMode,
			},
		},
	}

	response, err := client.UpdateBandwidth(request)
	if err != nil {
		return err
	}
	fmt.Printf("Update response: %+v\n", response)
	return nil
}

这个函数构造了更新带宽的API请求，并处理响应或可能出现的错误。

使用协程和定时器

Go的并发模型让我们能够用协程（goroutines）和定时器轻松实现这个需求。

	go func() {
		if err := updateBandwidth(eipClient, bandwidthId, "xxxxx", sizeBandwidth, model.GetUpdateBandwidthOptionChargeModeEnum().BANDWIDTH); err != nil {
			fmt.Printf("更新带宽时出错: %s\n", err)
			return
		}

		// 设置计时器在10分钟后切换回流量计费模式。
		timer := time.NewTimer(1 * time.Minute)
		<-timer.C

		if err := updateBandwidth(eipClient, bandwidthId, "xxxxxx", sizeTrafficBandwidth, model.GetUpdateBandwidthOptionChargeModeEnum().TRAFFIC); err != nil {
			fmt.Printf("恢复带宽时出错: %s\n", err)
			return
		}
	}()

	// 使用通道阻塞主 goroutine 无限期。避免在空的 select 语句中旋转，这是不必要的。
	done := make(chan struct{})
	<-done
}

第一版代码

完整代码如下：

package main

import (
	"fmt"
	"time"

	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/config"
	eip "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/model"
	region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/region"
)

func main() {
	// Replace with your own AK/SK, Region, and Project ID.
	ak := "xxxxxx"
	sk := "xxxxxx"
	projectID := "xxxxxx"

	// Authenticate using your Access Key and Secret Key.
	auth := basic.NewCredentialsBuilder().
		WithAk(ak).
		WithSk(sk).
		WithProjectId(projectID).
		Build()

	// Create EIP client configuration.
	eipClient := eip.NewEipClient(
		eip.EipClientBuilder().
			WithRegion(region.ValueOf("cn-east-3")).
			WithCredential(auth).
			WithHttpConfig(config.DefaultHttpConfig()).
			Build(),
	)

	// Replace the bandwidthId with your actual bandwidth ID.
	bandwidthId := "xxxx"
	sizeBandwidth := int32(xxx)
    sizeTrafficBandwidth := int32(xxx)

	// Update bandwidth to 10 Mbps and set to bandwidth billing mode.
	if err := updateBandwidth(eipClient, bandwidthId, "xxxx", sizeBandwidth, model.GetUpdateBandwidthOptionChargeModeEnum().BANDWIDTH); err != nil {
		fmt.Printf("Error updating bandwidth: %s\n", err)
		return
	}
	// Set a timer to switch back to traffic billing mode after 1 hour.
	time.AfterFunc(1*time.Hour, func() {
		if err := updateBandwidth(eipClient, bandwidthId, "xxxxx", sizeBandwidth, model.GetUpdateBandwidthOptionChargeModeEnum().TRAFFIC); err != nil {
			fmt.Printf("Error reverting bandwidth: %s\n", err)
			return
		}
	})

	// Block the main goroutine to not exit immediately.
	select {}
}

// Function to update the bandwidth of an EIP.
func updateBandwidth(client *eip.EipClient, bandwidthId, name string, size int32, chargeMode model.UpdateBandwidthOptionChargeMode) error {
	request := &model.UpdateBandwidthRequest{
		BandwidthId: bandwidthId,
		Body: &model.UpdateBandwidthRequestBody{
			Bandwidth: &model.UpdateBandwidthOption{
				Name:       &name,
				Size:       &size,
				ChargeMode: &chargeMode,
			},
		},
	}

	response, err := client.UpdateBandwidth(request)
	if err != nil {
		return err
	}
	fmt.Printf("Update response: %+v\n", response)
	return nil
}

运行main.go
jenkins Job华为云EIP变更带宽,jenkins,linux工具,华为云,jenkins,华为云,devops,运维开发
可以在控制台查看代码操作，控制台对应实例生效！

继续完善代码：

上面的代码是用户传入bandwidthId，这关键一般用户不知道bandwidthId 阿？控制台用户来说一般能知道的是公网IP：
jenkins Job华为云EIP变更带宽,jenkins,linux工具,华为云,jenkins,华为云,devops,运维开发
我这里想到的是使用ListPublicips-查询弹性公网IP列表获取bandwidth_name bandwidth_id。 创建两个函数：getBandwidthIdByPublicIP getBandwidthNameByPublicIP：

// 这里假设有一个通过公网IP获取带宽ID的函数
func getBandwidthIdByPublicIP(client *eip.EipClient, publicIP string) (string, error) {
	// 首先构造查询请求
	request := &model.ListPublicipsRequest{
		// 根据需要设置查询参数
	}

	// 调用SDK方法查询EIP详情
	response, err := client.ListPublicips(request)
	if err != nil {
		return "", err
	}

	// 遍历响应中的公共IP地址
	for _, publicip := range *response.Publicips { // 假设返回的是指针指向的切片
		// 检查 PublicIpAddress 是否为nil，并解引用来比较值
		if publicip.PublicIpAddress != nil && *publicip.PublicIpAddress == publicIP {
			// 检查 BandwidthId 是否为nil，并解引用来返回值
			if publicip.BandwidthId != nil {
				return *publicip.BandwidthId, nil
			}
			break // 如果 BandwidthId 为nil，则结束循环
		}
	}

	// 如果没有找到匹配的公共IP地址或带宽ID是nil，则返回错误
	return "", errors.New("public IP not found or bandwidth ID is nil")
}
func getBandwidthNameByPublicIP(client *eip.EipClient, publicIP string) (string, error) {
	// 首先构造查询请求
	request := &model.ListPublicipsRequest{
		// 根据需要设置查询参数
	}

	// 调用SDK方法查询EIP详情
	response, err := client.ListPublicips(request)
	if err != nil {
		return "", err
	}

	// 遍历响应中的公共IP地址
	for _, publicip := range *response.Publicips { // 假设返回的是指针指向的切片
		// 检查 PublicIpAddress 是否为nil，并解引用来比较值
		if publicip.PublicIpAddress != nil && *publicip.PublicIpAddress == publicIP {
			// 检查 BandwidthId 是否为nil，并解引用来返回值
			if publicip.BandwidthName != nil {
				return *publicip.BandwidthName, nil
			}
			break // 如果 BandwidthId 为nil，则结束循环
		}
	}

	// 如果没有找到匹配的公共IP地址或带宽ID是nil，则返回错误
	return "", errors.New("public IP not found or bandwidth ID is nil")
}

继续完善一下，通过运行main.go传入公网IP,固定带宽，恢复按量计费后的带宽大小，以及修改为固定带宽的持续时间。

go run main.go publicIP  sizeBandwidth sizeTrafficBandwidth timerMinutes

package main

import (
	"errors"
	"fmt"
	"os"
	"strconv"
	"time"

	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/config"
	eip "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/model"
	region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/region"
)

func main() {
	// Replace with your own AK/SK, Region, and Project ID.
	ak := "xxxxxx"
	sk := "xxxxxx"
	projectID := "xxxxxx"
	if len(os.Args) != 5 {
		fmt.Println("Usage: go run main.go <publicIP> <sizeBandwidth> <sizeTrafficBandwidth> <timerMinutes>")
		return
	}

	publicIP := os.Args[1]
	sizeBandwidth, err := strconv.Atoi(os.Args[2])
	if err != nil {
		fmt.Println("Invalid sizeBandwidth:", err)
		return
	}
	sizeTrafficBandwidth, err := strconv.Atoi(os.Args[3])
	if err != nil {
		fmt.Println("Invalid sizeTrafficBandwidth:", err)
		return
	}
	timerMinutes, err := strconv.Atoi(os.Args[4])
	if err != nil {
		fmt.Println("Invalid timerMinutes:", err)
		return
	}
	// Authenticate using your Access Key and Secret Key.
	auth := basic.NewCredentialsBuilder().
		WithAk(ak).
		WithSk(sk).
		WithProjectId(projectID).
		Build()

	// Create EIP client configuration.
	eipClient := eip.NewEipClient(
		eip.EipClientBuilder().
			WithRegion(region.ValueOf("cn-east-3")).
			WithCredential(auth).
			WithHttpConfig(config.DefaultHttpConfig()).
			Build(),
	)

	bandwidthId, err := getBandwidthIdByPublicIP(eipClient, publicIP)
	if err != nil {
		fmt.Println(err)
		return
	}
	bandwidthName, err := getBandwidthNameByPublicIP(eipClient, publicIP)
	if err != nil {
		fmt.Println(err)
		return
	}
	go func() {
		if err := updateBandwidth(eipClient, bandwidthId, bandwidthName, int32(sizeBandwidth), model.GetUpdateBandwidthOptionChargeModeEnum().BANDWIDTH); err != nil {
			fmt.Printf("更新带宽时出错: %s\n", err)
			return
		}

		// 设置计时器在10分钟后切换回流量计费模式。
		timer := time.NewTimer(time.Duration(timerMinutes) * time.Minute)
		<-timer.C

		if err := updateBandwidth(eipClient, bandwidthId, bandwidthName, int32(sizeTrafficBandwidth), model.GetUpdateBandwidthOptionChargeModeEnum().TRAFFIC); err != nil {
			fmt.Printf("恢复带宽时出错: %s\n", err)
			return
		}
	}()

	// 使用通道阻塞主 goroutine 无限期。避免在空的 select 语句中旋转，这是不必要的。
	done := make(chan struct{})
	<-done
}

// 这里假设有一个通过公网IP获取带宽ID的函数
func getBandwidthIdByPublicIP(client *eip.EipClient, publicIP string) (string, error) {
	// 首先构造查询请求
	request := &model.ListPublicipsRequest{
		// 根据需要设置查询参数
	}

	// 调用SDK方法查询EIP详情
	response, err := client.ListPublicips(request)
	if err != nil {
		return "", err
	}

	// 遍历响应中的公共IP地址
	for _, publicip := range *response.Publicips { // 假设返回的是指针指向的切片
		// 检查 PublicIpAddress 是否为nil，并解引用来比较值
		if publicip.PublicIpAddress != nil && *publicip.PublicIpAddress == publicIP {
			// 检查 BandwidthId 是否为nil，并解引用来返回值
			if publicip.BandwidthId != nil {
				return *publicip.BandwidthId, nil
			}
			break // 如果 BandwidthId 为nil，则结束循环
		}
	}

	// 如果没有找到匹配的公共IP地址或带宽ID是nil，则返回错误
	return "", errors.New("public IP not found or bandwidth ID is nil")
}
func getBandwidthNameByPublicIP(client *eip.EipClient, publicIP string) (string, error) {
	// 首先构造查询请求
	request := &model.ListPublicipsRequest{
		// 根据需要设置查询参数
	}

	// 调用SDK方法查询EIP详情
	response, err := client.ListPublicips(request)
	if err != nil {
		return "", err
	}

	// 遍历响应中的公共IP地址
	for _, publicip := range *response.Publicips { // 假设返回的是指针指向的切片
		// 检查 PublicIpAddress 是否为nil，并解引用来比较值
		if publicip.PublicIpAddress != nil && *publicip.PublicIpAddress == publicIP {
			// 检查 BandwidthId 是否为nil，并解引用来返回值
			if publicip.BandwidthName != nil {
				return *publicip.BandwidthName, nil
			}
			break // 如果 BandwidthId 为nil，则结束循环
		}
	}

	// 如果没有找到匹配的公共IP地址或带宽ID是nil，则返回错误
	return "", errors.New("public IP not found or bandwidth ID is nil")
}

// Function to update the bandwidth of an EIP.
func updateBandwidth(client *eip.EipClient, bandwidthId, name string, size int32, chargeMode model.UpdateBandwidthOptionChargeMode) error {
	request := &model.UpdateBandwidthRequest{
		BandwidthId: bandwidthId,
		Body: &model.UpdateBandwidthRequestBody{
			Bandwidth: &model.UpdateBandwidthOption{
				Name:       &name,
				Size:       &size,
				ChargeMode: &chargeMode,
			},
		},
	}

	response, err := client.UpdateBandwidth(request)
	if err != nil {
		return err
	}
	fmt.Printf("Update response: %+v\n", response)
	return nil
}

jenkins运行以上代码实例

最终我需要在jenkins中运行这个更改流量的任务，我将引用ak，sk引用jenkins凭据的方式：
参照之前刷新cdn时候引用凭据的方式：
jenkins Job华为云EIP变更带宽,jenkins,linux工具,华为云,jenkins,华为云,devops,运维开发
最终代码如下：

package main

import (
	"errors"
	"fmt"
	"os"
	"strconv"
	"time"

	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/config"
	eip "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/model"
	region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/region"
)

func main() {
	// Replace with your own AK/SK, Region, and Project ID.
	// 尝试从环境变量中获取ak和sk
	creds := os.Getenv("huaweiyun-hn-cdn")
	if creds == "" {
		fmt.Fprintln(os.Stderr, "Error: Credentials environment variable is not set.")
		os.Exit(1)
	}

	parts := strings.SplitN(creds, ":", 2)
	if len(parts) != 2 {
		fmt.Fprintln(os.Stderr, "Error: Invalid credential format. Expected 'AK:SK'.")
		os.Exit(1)
	}

	ak, sk := parts[0], parts[1]
	projectID := "xxxxxx"
	if len(os.Args) != 5 {
		fmt.Println("Usage: go run main.go <publicIP> <sizeBandwidth> <sizeTrafficBandwidth> <timerMinutes>")
		return
	}

	publicIP := os.Args[1]
	sizeBandwidth, err := strconv.Atoi(os.Args[2])
	if err != nil {
		fmt.Println("Invalid sizeBandwidth:", err)
		return
	}
	sizeTrafficBandwidth, err := strconv.Atoi(os.Args[3])
	if err != nil {
		fmt.Println("Invalid sizeTrafficBandwidth:", err)
		return
	}
	timerMinutes, err := strconv.Atoi(os.Args[4])
	if err != nil {
		fmt.Println("Invalid timerMinutes:", err)
		return
	}
	// Authenticate using your Access Key and Secret Key.
	auth := basic.NewCredentialsBuilder().
		WithAk(ak).
		WithSk(sk).
		WithProjectId(projectID).
		Build()

	// Create EIP client configuration.
	eipClient := eip.NewEipClient(
		eip.EipClientBuilder().
			WithRegion(region.ValueOf("cn-east-3")).
			WithCredential(auth).
			WithHttpConfig(config.DefaultHttpConfig()).
			Build(),
	)

	bandwidthId, err := getBandwidthIdByPublicIP(eipClient, publicIP)
	if err != nil {
		fmt.Println(err)
		return
	}
	bandwidthName, err := getBandwidthNameByPublicIP(eipClient, publicIP)
	if err != nil {
		fmt.Println(err)
		return
	}
	go func() {
		if err := updateBandwidth(eipClient, bandwidthId, bandwidthName, int32(sizeBandwidth), model.GetUpdateBandwidthOptionChargeModeEnum().BANDWIDTH); err != nil {
			fmt.Printf("更新带宽时出错: %s\n", err)
			return
		}

		// 设置计时器在10分钟后切换回流量计费模式。
		timer := time.NewTimer(time.Duration(timerMinutes) * time.Minute)
		<-timer.C

		if err := updateBandwidth(eipClient, bandwidthId, bandwidthName, int32(sizeTrafficBandwidth), model.GetUpdateBandwidthOptionChargeModeEnum().TRAFFIC); err != nil {
			fmt.Printf("恢复带宽时出错: %s\n", err)
			return
		}
	}()

	// 使用通道阻塞主 goroutine 无限期。避免在空的 select 语句中旋转，这是不必要的。
	done := make(chan struct{})
	<-done
}

// 这里假设有一个通过公网IP获取带宽ID的函数
func getBandwidthIdByPublicIP(client *eip.EipClient, publicIP string) (string, error) {
	// 首先构造查询请求
	request := &model.ListPublicipsRequest{
		// 根据需要设置查询参数
	}

	// 调用SDK方法查询EIP详情
	response, err := client.ListPublicips(request)
	if err != nil {
		return "", err
	}

	// 遍历响应中的公共IP地址
	for _, publicip := range *response.Publicips { // 假设返回的是指针指向的切片
		// 检查 PublicIpAddress 是否为nil，并解引用来比较值
		if publicip.PublicIpAddress != nil && *publicip.PublicIpAddress == publicIP {
			// 检查 BandwidthId 是否为nil，并解引用来返回值
			if publicip.BandwidthId != nil {
				return *publicip.BandwidthId, nil
			}
			break // 如果 BandwidthId 为nil，则结束循环
		}
	}

	// 如果没有找到匹配的公共IP地址或带宽ID是nil，则返回错误
	return "", errors.New("public IP not found or bandwidth ID is nil")
}
func getBandwidthNameByPublicIP(client *eip.EipClient, publicIP string) (string, error) {
	// 首先构造查询请求
	request := &model.ListPublicipsRequest{
		// 根据需要设置查询参数
	}

	// 调用SDK方法查询EIP详情
	response, err := client.ListPublicips(request)
	if err != nil {
		return "", err
	}

	// 遍历响应中的公共IP地址
	for _, publicip := range *response.Publicips { // 假设返回的是指针指向的切片
		// 检查 PublicIpAddress 是否为nil，并解引用来比较值
		if publicip.PublicIpAddress != nil && *publicip.PublicIpAddress == publicIP {
			// 检查 BandwidthId 是否为nil，并解引用来返回值
			if publicip.BandwidthName != nil {
				return *publicip.BandwidthName, nil
			}
			break // 如果 BandwidthId 为nil，则结束循环
		}
	}

	// 如果没有找到匹配的公共IP地址或带宽ID是nil，则返回错误
	return "", errors.New("public IP not found or bandwidth ID is nil")
}

// Function to update the bandwidth of an EIP.
func updateBandwidth(client *eip.EipClient, bandwidthId, name string, size int32, chargeMode model.UpdateBandwidthOptionChargeMode) error {
	request := &model.UpdateBandwidthRequest{
		BandwidthId: bandwidthId,
		Body: &model.UpdateBandwidthRequestBody{
			Bandwidth: &model.UpdateBandwidthOption{
				Name:       &name,
				Size:       &size,
				ChargeMode: &chargeMode,
			},
		},
	}

	response, err := client.UpdateBandwidth(request)
	if err != nil {
		return err
	}
	fmt.Printf("Update response: %+v\n", response)
	return nil
}

go build main.go，编译为可执行程序！将可执行程序放在工作节点上，jenkins 做了一个demo
参数化构建，字符参数：
jenkins Job华为云EIP变更带宽,jenkins,linux工具,华为云,jenkins,华为云,devops,运维开发
绑定密钥文件：

Build Steps 执行shell

cd /home/eip-hw&&./main $publicIP $sizeBandwidth $sizeTrafficBandwidth $timerMinutes

jenkins Job华为云EIP变更带宽,jenkins,linux工具,华为云,jenkins,华为云,devops,运维开发
输入publicIP运行程序：

程序运行生效，但是进程没有退出：

最终go相关代码：

继续完善一下代码，当程序运行完成后，退出程序。输出Bandwidth update successful, exiting：

package main

import (
	"errors"
	"fmt"
	"os"
	"strconv"
	"time"
        "strings"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/auth/basic"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/core/config"
	eip "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2"
	"github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/model"
	region "github.com/huaweicloud/huaweicloud-sdk-go-v3/services/eip/v2/region"
)

func main() {
	// Replace with your own AK/SK, Region, and Project ID.
	// 尝试从环境变量中获取ak和sk
	creds := os.Getenv("xxxxxx")
	if creds == "" {
		fmt.Fprintln(os.Stderr, "Error: Credentials environment variable is not set.")
		os.Exit(1)
	}

	parts := strings.SplitN(creds, ":", 2)
	if len(parts) != 2 {
		fmt.Fprintln(os.Stderr, "Error: Invalid credential format. Expected 'AK:SK'.")
		os.Exit(1)
	}

	ak, sk := parts[0], parts[1]
	projectID := "xxxxxx"
	if len(os.Args) != 5 {
		fmt.Println("Usage: go run main.go <publicIP> <sizeBandwidth> <sizeTrafficBandwidth> <timerMinutes>")
		return
	}

	publicIP := os.Args[1]
	sizeBandwidth, err := strconv.Atoi(os.Args[2])
	if err != nil {
		fmt.Println("Invalid sizeBandwidth:", err)
		return
	}
	sizeTrafficBandwidth, err := strconv.Atoi(os.Args[3])
	if err != nil {
		fmt.Println("Invalid sizeTrafficBandwidth:", err)
		return
	}
	timerMinutes, err := strconv.Atoi(os.Args[4])
	if err != nil {
		fmt.Println("Invalid timerMinutes:", err)
		return
	}
	// Authenticate using your Access Key and Secret Key.
	auth := basic.NewCredentialsBuilder().
		WithAk(ak).
		WithSk(sk).
		WithProjectId(projectID).
		Build()

	// Create EIP client configuration.
	eipClient := eip.NewEipClient(
		eip.EipClientBuilder().
			WithRegion(region.ValueOf("cn-east-3")).
			WithCredential(auth).
			WithHttpConfig(config.DefaultHttpConfig()).
			Build(),
	)

	bandwidthId, err := getBandwidthIdByPublicIP(eipClient, publicIP)
	if err != nil {
		fmt.Println(err)
		return
	}
	bandwidthName, err := getBandwidthNameByPublicIP(eipClient, publicIP)
	if err != nil {
		fmt.Println(err)
		return
	}
	go func() {
		if err := updateBandwidth(eipClient, bandwidthId, bandwidthName, int32(sizeBandwidth), model.GetUpdateBandwidthOptionChargeModeEnum().BANDWIDTH); err != nil {
			fmt.Printf("更新带宽时出错: %s\n", err)
			 os.Exit(1)
			return
		}

		// 设置计时器在10分钟后切换回流量计费模式。
		timer := time.NewTimer(time.Duration(timerMinutes) * time.Minute)
		<-timer.C

		if err := updateBandwidth(eipClient, bandwidthId, bandwidthName, int32(sizeTrafficBandwidth), model.GetUpdateBandwidthOptionChargeModeEnum().TRAFFIC); err != nil {
			fmt.Printf("恢复带宽时出错: %s\n", err)
			os.Exit(1)
			return
		}
		fmt.Println("Bandwidth update successful, exiting.") // Log success message
                os.Exit(0) // Exit the process after success
	}()

	// 使用通道阻塞主 goroutine 无限期。避免在空的 select 语句中旋转，这是不必要的。
	done := make(chan struct{})
	<-done
}

// 这里假设有一个通过公网IP获取带宽ID的函数
func getBandwidthIdByPublicIP(client *eip.EipClient, publicIP string) (string, error) {
	// 首先构造查询请求
	request := &model.ListPublicipsRequest{
		// 根据需要设置查询参数
	}

	// 调用SDK方法查询EIP详情
	response, err := client.ListPublicips(request)
	if err != nil {
		return "", err
	}

	// 遍历响应中的公共IP地址
	for _, publicip := range *response.Publicips { // 假设返回的是指针指向的切片
		// 检查 PublicIpAddress 是否为nil，并解引用来比较值
		if publicip.PublicIpAddress != nil && *publicip.PublicIpAddress == publicIP {
			// 检查 BandwidthId 是否为nil，并解引用来返回值
			if publicip.BandwidthId != nil {
				return *publicip.BandwidthId, nil
			}
			break // 如果 BandwidthId 为nil，则结束循环
		}
	}

	// 如果没有找到匹配的公共IP地址或带宽ID是nil，则返回错误
	return "", errors.New("public IP not found or bandwidth ID is nil")
}
func getBandwidthNameByPublicIP(client *eip.EipClient, publicIP string) (string, error) {
	// 首先构造查询请求
	request := &model.ListPublicipsRequest{
		// 根据需要设置查询参数
	}

	// 调用SDK方法查询EIP详情
	response, err := client.ListPublicips(request)
	if err != nil {
		return "", err
	}

	// 遍历响应中的公共IP地址
	for _, publicip := range *response.Publicips { // 假设返回的是指针指向的切片
		// 检查 PublicIpAddress 是否为nil，并解引用来比较值
		if publicip.PublicIpAddress != nil && *publicip.PublicIpAddress == publicIP {
			// 检查 BandwidthId 是否为nil，并解引用来返回值
			if publicip.BandwidthName != nil {
				return *publicip.BandwidthName, nil
			}
			break // 如果 BandwidthId 为nil，则结束循环
		}
	}

	// 如果没有找到匹配的公共IP地址或带宽ID是nil，则返回错误
	return "", errors.New("public IP not found or bandwidth ID is nil")
}

// Function to update the bandwidth of an EIP.
func updateBandwidth(client *eip.EipClient, bandwidthId, name string, size int32, chargeMode model.UpdateBandwidthOptionChargeMode) error {
	request := &model.UpdateBandwidthRequest{
		BandwidthId: bandwidthId,
		Body: &model.UpdateBandwidthRequestBody{
			Bandwidth: &model.UpdateBandwidthOption{
				Name:       &name,
				Size:       &size,
				ChargeMode: &chargeMode,
			},
		},
	}

	response, err := client.UpdateBandwidth(request)
	if err != nil {
		return err
	}
	fmt.Printf("Update response: %+v\n", response)
	return nil
}

jenkins Job华为云EIP变更带宽,jenkins,linux工具,华为云,jenkins,华为云,devops,运维开发
ok这样就简单实现了！
注：以上代码chatgpt生成，个人进行了更改整理.文章来源地址https://www.toymoban.com/news/detail-774260.html