4.0.0

internal/service/cloudbroker/k8s/node_subresource.go

@@ -31,43 +31,68 @@ Documentation: https://repository.basistech.ru/BASIS/terraform-provider-decort/w
 
 package k8s
 
-import "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+import (
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/k8s"
+)
 
-func nodeMasterDefault() K8sNodeRecord {
-	return K8sNodeRecord{
+func nodeMasterDefault() k8s.MasterGroup {
+	return k8s.MasterGroup{
 		Num:  1,
-		Cpu:  2,
-		Ram:  2048,
+		CPU:  2,
+		RAM:  2048,
 		Disk: 0,
 	}
 }
 
-func nodeWorkerDefault() K8sNodeRecord {
-	return K8sNodeRecord{
+func nodeWorkerDefault() k8s.RecordK8SGroup {
+	return k8s.RecordK8SGroup{
 		Num:  1,
-		Cpu:  1,
-		Ram:  1024,
+		CPU:  1,
+		RAM:  1024,
 		Disk: 0,
 	}
 }
 
-func parseNode(nodeList []interface{}) K8sNodeRecord {
+func parseWorkerNode(nodeList []interface{}) k8s.RecordK8SGroup {
 	node := nodeList[0].(map[string]interface{})
 
-	return K8sNodeRecord{
-		Num:  node["num"].(int),
-		Cpu:  node["cpu"].(int),
-		Ram:  node["ram"].(int),
-		Disk: node["disk"].(int),
+	return k8s.RecordK8SGroup{
+		Num:  uint64(node["num"].(int)),
+		CPU:  uint64(node["cpu"].(int)),
+		RAM:  uint64(node["ram"].(int)),
+		Disk: uint64(node["disk"].(int)),
 	}
 }
 
-func nodeToResource(node K8sNodeRecord) []interface{} {
+func parseMasterNode(nodeList []interface{}) k8s.MasterGroup {
+	node := nodeList[0].(map[string]interface{})
+
+	return k8s.MasterGroup{
+		Num:  uint64(node["num"].(int)),
+		CPU:  uint64(node["cpu"].(int)),
+		RAM:  uint64(node["ram"].(int)),
+		Disk: uint64(node["disk"].(int)),
+	}
+}
+
+func workerNodeToResource(node k8s.RecordK8SGroup) []interface{} {
 	mp := make(map[string]interface{})
 
 	mp["num"] = node.Num
-	mp["cpu"] = node.Cpu
-	mp["ram"] = node.Ram
+	mp["cpu"] = node.CPU
+	mp["ram"] = node.RAM
+	mp["disk"] = node.Disk
+
+	return []interface{}{mp}
+}
+
+func masterNodeToResource(node k8s.MasterGroup) []interface{} {
+	mp := make(map[string]interface{})
+
+	mp["num"] = node.Num
+	mp["cpu"] = node.CPU
+	mp["ram"] = node.RAM
 	mp["disk"] = node.Disk
 
 	return []interface{}{mp}

internal/service/cloudbroker/k8s/resource_k8s.go

@@ -33,85 +33,84 @@ package k8s
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
-	"net/url"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/k8s"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/lb"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/tasks"
 	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
 	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
-	log "github.com/sirupsen/logrus"
 )
 
 func resourceK8sCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
 	log.Debugf("resourceK8sCreate: called with name %s, rg %d", d.Get("name").(string), d.Get("rg_id").(int))
 
 	c := m.(*controller.ControllerCfg)
-	urlValues := &url.Values{}
-	urlValues.Add("name", d.Get("name").(string))
-	urlValues.Add("rgId", strconv.Itoa(d.Get("rg_id").(int)))
-	urlValues.Add("k8ciId", strconv.Itoa(d.Get("k8sci_id").(int)))
-	urlValues.Add("workerGroupName", d.Get("wg_name").(string))
+	req := k8s.CreateRequest{}
 
-	var masterNode K8sNodeRecord
+	req.Name = d.Get("name").(string)
+	req.RGID = uint64(d.Get("rg_id").(int))
+	req.K8CIID = uint64(d.Get("k8sci_id").(int))
+	req.WorkerGroupName = d.Get("wg_name").(string)
+
+	var masterNode k8s.MasterGroup
 	if masters, ok := d.GetOk("masters"); ok {
-		masterNode = parseNode(masters.([]interface{}))
+		masterNode = parseMasterNode(masters.([]interface{}))
 	} else {
 		masterNode = nodeMasterDefault()
 	}
-	urlValues.Add("masterNum", strconv.Itoa(masterNode.Num))
-	urlValues.Add("masterCpu", strconv.Itoa(masterNode.Cpu))
-	urlValues.Add("masterRam", strconv.Itoa(masterNode.Ram))
-	urlValues.Add("masterDisk", strconv.Itoa(masterNode.Disk))
+	req.MasterNum = uint64(masterNode.Num)
+	req.MasterCPU = uint64(masterNode.CPU)
+	req.MasterRAM = uint64(masterNode.RAM)
+	req.MasterDisk = uint64(masterNode.Disk)
 
-	var workerNode K8sNodeRecord
+	var workerNode k8s.RecordK8SGroup
 	if workers, ok := d.GetOk("workers"); ok {
-		workerNode = parseNode(workers.([]interface{}))
+		workerNode = parseWorkerNode(workers.([]interface{}))
 	} else {
 		workerNode = nodeWorkerDefault()
 	}
-	urlValues.Add("workerNum", strconv.Itoa(workerNode.Num))
-	urlValues.Add("workerCpu", strconv.Itoa(workerNode.Cpu))
-	urlValues.Add("workerRam", strconv.Itoa(workerNode.Ram))
-	urlValues.Add("workerDisk", strconv.Itoa(workerNode.Disk))
+	req.WorkerNum = uint64(workerNode.Num)
+	req.WorkerCPU = uint64(workerNode.CPU)
+	req.WorkerRAM = uint64(workerNode.RAM)
+	req.WorkerDisk = uint64(workerNode.Disk)
 
-	//if withLB, ok := d.GetOk("with_lb"); ok {
-	//urlValues.Add("withLB", strconv.FormatBool(withLB.(bool)))
-	//}
-	urlValues.Add("withLB", strconv.FormatBool(true))
-
-	if extNet, ok := d.GetOk("extnet_id"); ok {
-		urlValues.Add("extnetId", strconv.Itoa(extNet.(int)))
+	if withLB, ok := d.GetOk("with_lb"); ok {
+		req.WithLB = withLB.(bool)
 	} else {
-		urlValues.Add("extnetId", "0")
+		req.WithLB = true
 	}
 
-	//if desc, ok := d.GetOk("desc"); ok {
-	//urlValues.Add("desc", desc.(string))
-	//}
+	if extNet, ok := d.GetOk("extnet_id"); ok {
+		req.ExtNetID = uint64(extNet.(int))
+	} else {
+		req.ExtNetID = 0
+	}
 
-	resp, err := c.DecortAPICall(ctx, "POST", K8sCreateAPI, urlValues)
+	if desc, ok := d.GetOk("desc"); ok {
+		req.Description = desc.(string)
+	}
+
+	resp, err := c.CloudBroker().K8S().Create(ctx, req)
 	if err != nil {
 		return diag.FromErr(err)
 	}
 
-	urlValues = &url.Values{}
-	urlValues.Add("auditId", strings.Trim(resp, `"`))
+	tasksReq := tasks.GetRequest{
+		AuditID: resp,
+	}
 
 	for {
-		resp, err := c.DecortAPICall(ctx, "POST", AsyncTaskGetAPI, urlValues)
+		task, err := c.CloudBroker().Tasks().Get(ctx, tasksReq)
 		if err != nil {
 			return diag.FromErr(err)
 		}
 
-		task := AsyncTask{}
-		if err := json.Unmarshal([]byte(resp), &task); err != nil {
-			return diag.FromErr(err)
-		}
 		log.Debugf("resourceK8sCreate: instance creating - %s", task.Stage)
 
 		if task.Completed {
@@ -126,78 +125,50 @@ func resourceK8sCreate(ctx context.Context, d *schema.ResourceData, m interface{
 		time.Sleep(time.Second * 10)
 	}
 
-	k8s, err := utilityK8sCheckPresence(ctx, d, m)
-	if err != nil {
-		return diag.FromErr(err)
-	}
-
-	d.Set("default_wg_id", k8s.Groups.Workers[0].ID)
-
-	urlValues = &url.Values{}
-	urlValues.Add("lbId", strconv.Itoa(k8s.LbID))
-
-	resp, err = c.DecortAPICall(ctx, "POST", LbGetAPI, urlValues)
-	if err != nil {
-		return diag.FromErr(err)
-	}
-
-	var lb LbRecord
-	if err := json.Unmarshal([]byte(resp), &lb); err != nil {
-		return diag.FromErr(err)
-	}
-	d.Set("extnet_id", lb.ExtNetID)
-	d.Set("lb_ip", lb.PrimaryNode.FrontendIP)
-
-	urlValues = &url.Values{}
-	urlValues.Add("k8sId", d.Id())
-	kubeconfig, err := c.DecortAPICall(ctx, "POST", K8sGetConfigAPI, urlValues)
-	if err != nil {
-		log.Warnf("could not get kubeconfig: %v", err)
-	}
-	d.Set("kubeconfig", kubeconfig)
-
-	return nil
+	return resourceK8sRead(ctx, d, m)
 }
 
 func resourceK8sRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
 	log.Debugf("resourceK8sRead: called with id %s, rg %d", d.Id(), d.Get("rg_id").(int))
 
-	k8s, err := utilityK8sCheckPresence(ctx, d, m)
-	if k8s == nil {
+	k8sData, err := utilityK8sCheckPresence(ctx, d, m)
+	if err != nil {
 		d.SetId("")
 		return diag.FromErr(err)
 	}
 
-	d.Set("name", k8s.Name)
-	d.Set("rg_id", k8s.RgID)
-	d.Set("k8sci_id", k8s.CI)
-	d.Set("wg_name", k8s.Groups.Workers[0].Name)
-	d.Set("masters", nodeToResource(k8s.Groups.Masters))
-	d.Set("workers", nodeToResource(k8s.Groups.Workers[0]))
-	d.Set("default_wg_id", k8s.Groups.Workers[0].ID)
+	d.Set("name", k8sData.Name)
+	d.Set("rg_id", k8sData.RGID)
+	d.Set("k8sci_id", k8sData.CIID)
+	d.Set("wg_name", k8sData.K8SGroups.Workers[0].Name)
+	d.Set("masters", masterNodeToResource(k8sData.K8SGroups.Masters))
+	d.Set("workers", workerNodeToResource(k8sData.K8SGroups.Workers[0]))
+	d.Set("default_wg_id", k8sData.K8SGroups.Workers[0].ID)
 
 	c := m.(*controller.ControllerCfg)
-	urlValues := &url.Values{}
-	urlValues.Add("lbId", strconv.Itoa(k8s.LbID))
 
-	resp, err := c.DecortAPICall(ctx, "POST", LbGetAPI, urlValues)
+	lbReq := lb.GetRequest{
+		LBID: k8sData.LBID,
+	}
+
+	lbData, err := c.CloudBroker().LB().Get(ctx, lbReq)
 	if err != nil {
 		return diag.FromErr(err)
 	}
 
-	var lb LbRecord
-	if err := json.Unmarshal([]byte(resp), &lb); err != nil {
-		return diag.FromErr(err)
-	}
-	d.Set("extnet_id", lb.ExtNetID)
-	d.Set("lb_ip", lb.PrimaryNode.FrontendIP)
+	d.Set("extnet_id", lbData.ExtNetID)
+	d.Set("lb_ip", lbData.PrimaryNode.FrontendIP)
 
-	urlValues = &url.Values{}
-	urlValues.Add("k8sId", d.Id())
-	kubeconfig, err := c.DecortAPICall(ctx, "POST", K8sGetConfigAPI, urlValues)
+	configReq := k8s.GetConfigRequest{
+		K8SID: k8sData.ID,
+	}
+
+	kubeconfig, err := c.CloudBroker().K8S().GetConfig(ctx, configReq)
 	if err != nil {
 		log.Warnf("could not get kubeconfig: %v", err)
+		return nil
 	}
+
 	d.Set("kubeconfig", kubeconfig)
 
 	return nil
@@ -207,40 +178,47 @@ func resourceK8sUpdate(ctx context.Context, d *schema.ResourceData, m interface{
 	log.Debugf("resourceK8sUpdate: called with id %s, rg %d", d.Id(), d.Get("rg_id").(int))
 
 	c := m.(*controller.ControllerCfg)
+	k8sId, _ := strconv.ParseUint(d.Id(), 10, 64)
 
 	if d.HasChange("name") {
-		urlValues := &url.Values{}
-		urlValues.Add("k8sId", d.Id())
-		urlValues.Add("name", d.Get("name").(string))
+		req := k8s.UpdateRequest{
+			K8SID: k8sId,
+			Name:  d.Get("name").(string),
+		}
 
-		_, err := c.DecortAPICall(ctx, "POST", K8sUpdateAPI, urlValues)
+		_, err := c.CloudBroker().K8S().Update(ctx, req)
 		if err != nil {
 			return diag.FromErr(err)
 		}
 	}
 
 	if d.HasChange("workers") {
-		k8s, err := utilityK8sCheckPresence(ctx, d, m)
+		k8sData, err := utilityK8sCheckPresence(ctx, d, m)
 		if err != nil {
 			return diag.FromErr(err)
 		}
 
-		wg := k8s.Groups.Workers[0]
-		urlValues := &url.Values{}
-		urlValues.Add("k8sId", d.Id())
-		urlValues.Add("workersGroupId", strconv.Itoa(wg.ID))
+		wg := k8sData.K8SGroups.Workers[0]
+		deleteReq := k8s.DeleteWorkerFromGroupRequest{
+			K8SID:          k8sId,
+			WorkersGroupID: wg.ID,
+		}
+		addReq := k8s.WorkerAddRequest{
+			K8SID:          k8sId,
+			WorkersGroupID: wg.ID,
+		}
 
-		newWorkers := parseNode(d.Get("workers").([]interface{}))
+		newWorkers := parseWorkerNode(d.Get("workers").([]interface{}))
 
 		if newWorkers.Num > wg.Num {
-			urlValues.Add("num", strconv.Itoa(newWorkers.Num-wg.Num))
-			if _, err := c.DecortAPICall(ctx, "POST", K8sWorkerAddAPI, urlValues); err != nil {
+			addReq.Num = uint64(newWorkers.Num - wg.Num)
+			if _, err := c.CloudBroker().K8S().WorkerAdd(ctx, addReq); err != nil {
 				return diag.FromErr(err)
 			}
 		} else {
 			for i := wg.Num - 1; i >= newWorkers.Num; i-- {
-				urlValues.Set("workerId", strconv.Itoa(wg.DetailedInfo[i].ID))
-				if _, err := c.DecortAPICall(ctx, "POST", K8sWorkerDeleteAPI, urlValues); err != nil {
+				deleteReq.WorkerID = wg.DetailedInfo[i].ID
+				if _, err := c.CloudBroker().K8S().DeleteWorkerFromGroup(ctx, deleteReq); err != nil {
 					return diag.FromErr(err)
 				}
 			}
@@ -253,20 +231,22 @@ func resourceK8sUpdate(ctx context.Context, d *schema.ResourceData, m interface{
 func resourceK8sDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
 	log.Debugf("resourceK8sDelete: called with id %s, rg %d", d.Id(), d.Get("rg_id").(int))
 
-	k8s, err := utilityK8sCheckPresence(ctx, d, m)
-	if k8s == nil {
-		if err != nil {
-			return diag.FromErr(err)
-		}
-		return nil
+	k8sData, err := utilityK8sCheckPresence(ctx, d, m)
+	if err != nil {
+		return diag.FromErr(err)
 	}
 
 	c := m.(*controller.ControllerCfg)
-	urlValues := &url.Values{}
-	urlValues.Add("k8sId", d.Id())
-	urlValues.Add("permanently", "true")
+	req := k8s.DeleteRequest{
+		K8SID: k8sData.ID,
+	}
+	if perm, ok := d.GetOk("permanently"); ok {
+		req.Permanently = perm.(bool)
+	} else {
+		req.Permanently = false
+	}
 
-	_, err = c.DecortAPICall(ctx, "POST", K8sDeleteAPI, urlValues)
+	_, err = c.CloudBroker().K8S().Delete(ctx, req)
 	if err != nil {
 		return diag.FromErr(err)
 	}

internal/service/cloudbroker/k8s/resource_k8s_wg.go

@@ -33,12 +33,11 @@ package k8s
 
 import (
 	"context"
-	"net/url"
-	"strconv"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	log "github.com/sirupsen/logrus"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/k8s"
 	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
 	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
 )
@@ -47,15 +46,16 @@ func resourceK8sWgCreate(ctx context.Context, d *schema.ResourceData, m interfac
 	log.Debugf("resourceK8sWgCreate: called with k8s id %d", d.Get("k8s_id").(int))
 
 	c := m.(*controller.ControllerCfg)
-	urlValues := &url.Values{}
-	urlValues.Add("k8sId", strconv.Itoa(d.Get("k8s_id").(int)))
-	urlValues.Add("name", d.Get("name").(string))
-	urlValues.Add("workerNum", strconv.Itoa(d.Get("num").(int)))
-	urlValues.Add("workerCpu", strconv.Itoa(d.Get("cpu").(int)))
-	urlValues.Add("workerRam", strconv.Itoa(d.Get("ram").(int)))
-	urlValues.Add("workerDisk", strconv.Itoa(d.Get("disk").(int)))
+	req := k8s.WorkersGroupAddRequest{
+		K8SID:      uint64(d.Get("k8s_id").(int)),
+		Name:       d.Get("name").(string),
+		WorkerNum:  uint64(d.Get("num").(int)),
+		WorkerCPU:  uint64(d.Get("cpu").(int)),
+		WorkerRAM:  uint64(d.Get("ram").(int)),
+		WorkerDisk: uint64(d.Get("disk").(int)),
+	}
 
-	resp, err := c.DecortAPICall(ctx, "POST", K8sWgCreateAPI, urlValues)
+	resp, err := c.CloudBroker().K8S().WorkersGroupAdd(ctx, req)
 	if err != nil {
 		return diag.FromErr(err)
 	}
@@ -69,15 +69,15 @@ func resourceK8sWgRead(ctx context.Context, d *schema.ResourceData, m interface{
 	log.Debugf("resourceK8sWgRead: called with k8s id %d", d.Get("k8s_id").(int))
 
 	wg, err := utilityK8sWgCheckPresence(ctx, d, m)
-	if wg == nil {
+	if err != nil {
 		d.SetId("")
 		return diag.FromErr(err)
 	}
 
 	d.Set("name", wg.Name)
 	d.Set("num", wg.Num)
-	d.Set("cpu", wg.Cpu)
-	d.Set("ram", wg.Ram)
+	d.Set("cpu", wg.CPU)
+	d.Set("ram", wg.RAM)
 	d.Set("disk", wg.Disk)
 
 	return nil
@@ -93,20 +93,26 @@ func resourceK8sWgUpdate(ctx context.Context, d *schema.ResourceData, m interfac
 		return diag.FromErr(err)
 	}
 
-	urlValues := &url.Values{}
-	urlValues.Add("k8sId", strconv.Itoa(d.Get("k8s_id").(int)))
-	urlValues.Add("workersGroupId", d.Id())
+	addReq := k8s.WorkerAddRequest{
+		K8SID:          uint64(d.Get("k8s_id").(int)),
+		WorkersGroupID: wg.ID,
+	}
 
-	if newNum := d.Get("num").(int); newNum > wg.Num {
-		urlValues.Add("num", strconv.Itoa(newNum-wg.Num))
-		_, err := c.DecortAPICall(ctx, "POST", K8sWorkerAddAPI, urlValues)
+	delReq := k8s.DeleteWorkerFromGroupRequest{
+		K8SID:          uint64(d.Get("k8s_id").(int)),
+		WorkersGroupID: wg.ID,
+	}
+
+	if newNum := uint64(d.Get("num").(int)); newNum > wg.Num {
+		addReq.Num = newNum - wg.Num
+		_, err := c.CloudBroker().K8S().WorkerAdd(ctx, addReq)
 		if err != nil {
 			return diag.FromErr(err)
 		}
 	} else {
 		for i := wg.Num - 1; i >= newNum; i-- {
-			urlValues.Set("workerId", strconv.Itoa(wg.DetailedInfo[i].ID))
-			_, err := c.DecortAPICall(ctx, "POST", K8sWorkerDeleteAPI, urlValues)
+			delReq.WorkerID = wg.DetailedInfo[i].ID
+			_, err := c.CloudBroker().K8S().DeleteWorkerFromGroup(ctx, delReq)
 			if err != nil {
 				return diag.FromErr(err)
 			}
@@ -120,23 +126,23 @@ func resourceK8sWgDelete(ctx context.Context, d *schema.ResourceData, m interfac
 	log.Debugf("resourceK8sWgDelete: called with k8s id %d", d.Get("k8s_id").(int))
 
 	wg, err := utilityK8sWgCheckPresence(ctx, d, m)
-	if wg == nil {
-		if err != nil {
-			return diag.FromErr(err)
-		}
-		return nil
-	}
-
-	c := m.(*controller.ControllerCfg)
-	urlValues := &url.Values{}
-	urlValues.Add("k8sId", strconv.Itoa(d.Get("k8s_id").(int)))
-	urlValues.Add("workersGroupId", strconv.Itoa(wg.ID))
-
-	_, err = c.DecortAPICall(ctx, "POST", K8sWgDeleteAPI, urlValues)
 	if err != nil {
 		return diag.FromErr(err)
 	}
 
+	c := m.(*controller.ControllerCfg)
+	req := k8s.WorkersGroupDeleteRequest{
+		K8SID:          uint64(d.Get("k8s_id").(int)),
+		WorkersGroupID: wg.ID,
+	}
+
+	_, err = c.CloudBroker().K8S().WorkersGroupDelete(ctx, req)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId("")
+
 	return nil
 }
 

internal/service/cloudbroker/k8s/utility_k8s.go

@@ -33,31 +33,24 @@ package k8s
 
 import (
 	"context"
-	"encoding/json"
-	"net/url"
+	"strconv"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/k8s"
 	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
 )
 
-func utilityK8sCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*K8sRecord, error) {
+func utilityK8sCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*k8s.RecordK8S, error) {
 	c := m.(*controller.ControllerCfg)
-	urlValues := &url.Values{}
-	urlValues.Add("k8sId", d.Id())
+	req := k8s.GetRequest{}
+	k8sId, _ := strconv.ParseUint(d.Id(), 10, 64)
 
-	resp, err := c.DecortAPICall(ctx, "POST", K8sGetAPI, urlValues)
+	req.K8SID = k8sId
+
+	k8s, err := c.CloudBroker().K8S().Get(ctx, req)
 	if err != nil {
 		return nil, err
 	}
 
-	if resp == "" {
-		return nil, nil
-	}
-
-	var k8s K8sRecord
-	if err := json.Unmarshal([]byte(resp), &k8s); err != nil {
-		return nil, err
-	}
-
-	return &k8s, nil
+	return k8s, nil
 }

internal/service/cloudbroker/k8s/utility_k8s_wg.go

@@ -33,40 +33,28 @@ package k8s
 
 import (
 	"context"
-	"encoding/json"
-	"net/url"
 	"strconv"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudbroker/k8s"
 	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/controller"
 )
 
-func utilityK8sWgCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*K8sNodeRecord, error) {
+func utilityK8sWgCheckPresence(ctx context.Context, d *schema.ResourceData, m interface{}) (*k8s.RecordK8SGroup, error) {
 	c := m.(*controller.ControllerCfg)
-	urlValues := &url.Values{}
-	urlValues.Add("k8sId", strconv.Itoa(d.Get("k8s_id").(int)))
+	req := k8s.GetRequest{
+		K8SID: uint64(d.Get("k8s_id").(int)),
+	}
 
-	resp, err := c.DecortAPICall(ctx, "POST", K8sGetAPI, urlValues)
+	k8sData, err := c.CloudBroker().K8S().Get(ctx, req)
 	if err != nil {
 		return nil, err
 	}
 
-	if resp == "" {
-		return nil, nil
-	}
+	k8sWgID, _ := strconv.ParseUint(d.Id(), 10, 64)
 
-	var k8s K8sRecord
-	if err := json.Unmarshal([]byte(resp), &k8s); err != nil {
-		return nil, err
-	}
-
-	id, err := strconv.Atoi(d.Id())
-	if err != nil {
-		return nil, err
-	}
-
-	for _, wg := range k8s.Groups.Workers {
-		if wg.ID == id {
+	for _, wg := range k8sData.K8SGroups.Workers {
+		if wg.ID == k8sWgID {
 			return &wg, nil
 		}
 	}