Setting and upgrading Kubernetes® versions in Managed Service for Kubernetes

clusterByName, err := sdk.Services().MK8S().V1().
    Cluster().GetByName(
        ctx,
        &common.GetByNameRequest{
            Name: "<cluster_name>",
        },
    )
if err != nil {
    return err
}
clusterByNameID := clusterByName.GetMetadata().GetId()
if clusterByNameID == "" {
    return errors.New("cluster ID is missing")
}
fmt.Println(clusterByNameID)

cluster, err := sdk.Services().MK8S().V1().
    Cluster().Get(
        ctx,
        &mk8s.GetClusterRequest{
            Id: "<cluster_ID>",
        },
    )
if err != nil {
    return err
}
clusterSpec := cluster.GetSpec()
if clusterSpec == nil || clusterSpec.GetControlPlane() == nil {
    return errors.New("cluster control plane spec is missing")
}
clusterSpec.GetControlPlane().Version = "<major.minor>"
clusterOperation, err := sdk.Services().MK8S().V1().
    Cluster().Update(
        ctx,
        &mk8s.UpdateClusterRequest{
            Metadata: cluster.GetMetadata(),
            Spec:     clusterSpec,
        },
    )
if err != nil {
    return err
}
if _, err = clusterOperation.Wait(ctx); err != nil {
    return err
}

nodeGroupByName, err := sdk.Services().MK8S().V1().
    NodeGroup().GetByName(
        ctx,
        &common.GetByNameRequest{
            ParentId: "<cluster_ID>",
            Name:     "<node_group_name>",
        },
    )
if err != nil {
    return err
}
nodeGroupByNameID := nodeGroupByName.GetMetadata().GetId()
if nodeGroupByNameID == "" {
    return errors.New("node group ID is missing")
}
fmt.Println(nodeGroupByNameID)

nodeGroup, err := sdk.Services().MK8S().V1().
    NodeGroup().Get(
        ctx,
        &mk8s.GetNodeGroupRequest{
            Id: "<node_group_ID>",
        },
    )
if err != nil {
    return err
}
nodeGroupSpec := nodeGroup.GetSpec()
if nodeGroupSpec == nil {
    return errors.New("node group spec is missing")
}
nodeGroupSpec.Version = "<major.minor>"
nodeGroupOperation, err := sdk.Services().MK8S().V1().
    NodeGroup().Update(
        ctx,
        &mk8s.UpdateNodeGroupRequest{
            Metadata: nodeGroup.GetMetadata(),
            Spec:     nodeGroupSpec,
        },
    )
if err != nil {
    return err
}
if _, err = nodeGroupOperation.Wait(ctx); err != nil {
    return err
}

cluster_service = ClusterServiceClient(sdk)
cluster_by_name = await cluster_service.get_by_name(
    GetByNameRequest(name="<cluster_name>"),
)
cluster_by_name_id = cluster_by_name.metadata.id
print(cluster_by_name_id)

cluster_service = ClusterServiceClient(sdk)
cluster = await cluster_service.get(
    GetClusterRequest(id="<cluster_ID>"),
)
if cluster.spec is None or cluster.spec.control_plane is None:
    raise ValueError("cluster control plane spec is missing")
cluster.spec.control_plane.version = "<major.minor>"
cluster_operation = await cluster_service.update(
    UpdateClusterRequest(
        metadata=cluster.metadata,
        spec=cluster.spec,
    ),
)
await cluster_operation.wait()

node_group_service = NodeGroupServiceClient(sdk)
node_group_by_name = await node_group_service.get_by_name(
    GetByNameRequest(
        parent_id="<cluster_ID>",
        name="<node_group_name>",
    ),
)
node_group_by_name_id = node_group_by_name.metadata.id
print(node_group_by_name_id)

node_group_service = NodeGroupServiceClient(sdk)
node_group = await node_group_service.get(
    GetNodeGroupRequest(id="<node_group_ID>"),
)
if node_group.spec is None:
    raise ValueError("node group spec is missing")
node_group.spec.version = "<major.minor>"
node_group_operation = await node_group_service.update(
    UpdateNodeGroupRequest(
        metadata=node_group.metadata,
        spec=node_group.spec,
    ),
)
await node_group_operation.wait()

const clusterLookupService = new ClusterService(sdk);
const clusterByName = await clusterLookupService.getByName(
  GetByNameRequest.create({
    name: "<cluster_name>",
  }),
);
const clusterByNameId = clusterByName.metadata?.id;
if (!clusterByNameId) {
  throw new Error("cluster ID is missing");
}
console.log(clusterByNameId);

const clusterService = new ClusterService(sdk);
const cluster = await clusterService.get(
  GetClusterRequest.create({
    id: "<cluster_ID>",
  }),
);
if (!cluster.spec?.controlPlane) {
  throw new Error("cluster control plane spec is missing");
}
cluster.spec.controlPlane.version = "<major.minor>";
const clusterOperation = await clusterService.update(
  UpdateClusterRequest.create({
    metadata: cluster.metadata,
    spec: cluster.spec,
  }),
).result;
await clusterOperation.wait();

const nodeGroupLookupService = new NodeGroupService(sdk);
const nodeGroupByName = await nodeGroupLookupService.getByName(
  GetByNameRequest.create({
    parentId: "<cluster_ID>",
    name: "<node_group_name>",
  }),
);
const nodeGroupByNameId = nodeGroupByName.metadata?.id;
if (!nodeGroupByNameId) {
  throw new Error("node group ID is missing");
}
console.log(nodeGroupByNameId);

const nodeGroupService = new NodeGroupService(sdk);
const nodeGroup = await nodeGroupService.get(
  GetNodeGroupRequest.create({
    id: "<node_group_ID>",
  }),
);
if (!nodeGroup.spec) {
  throw new Error("node group spec is missing");
}
nodeGroup.spec.version = "<major.minor>";
const nodeGroupOperation = await nodeGroupService.update(
  UpdateNodeGroupRequest.create({
    metadata: nodeGroup.metadata,
    spec: nodeGroup.spec,
  }),
).result;
await nodeGroupOperation.wait();