How to send an API request using the Go SDK

package main

import (
   "context"
   "fmt"

   "github.com/nebius/gosdk"
   "github.com/nebius/gosdk/auth"
   common "github.com/nebius/gosdk/proto/nebius/common/v1"
   compute "github.com/nebius/gosdk/proto/nebius/compute/v1"
)

// Run the resource creation workflow.
func main() {
   if err := CreateInstance(context.Background()); err != nil {
      panic(err)
   }
}

// CreateInstance creates a boot disk and a VM that uses it.
func CreateInstance(ctx context.Context) error {
   // Initialize the SDK with service account credentials.
   sdk, err := gosdk.New(
      ctx,
      gosdk.WithUserAgentPrefix("<application_name>/<application_version_or_comment>"),
      gosdk.WithCredentials(
         gosdk.ServiceAccountReader(
            auth.NewServiceAccountCredentialsFileParser(
               nil,
               "<credentials_file_path>",
            ),
         ),
      ),
   )
   if err != nil {
      return fmt.Errorf("create gosdk: %w", err)
   }
   defer sdk.Close()

   // Create the boot disk.
   diskOperation, err := sdk.Services().Compute().V1().Disk().Create(ctx, &compute.CreateDiskRequest{
      Metadata: &common.ResourceMetadata{
         ParentId: "<project_ID>",
         Name:     "my-boot-disk",
      },
      Spec: &compute.DiskSpec{
         Size: &compute.DiskSpec_SizeGibibytes{
            SizeGibibytes: 93,
         },
         Type: compute.DiskSpec_NETWORK_SSD,
         Source: &compute.DiskSpec_SourceImageFamily{
            SourceImageFamily: &compute.SourceImageFamily{
               ParentId:    "<project_ID>",
               ImageFamily: "<image_family_name>",
            },
         },
      },
   })
   if err != nil {
      return fmt.Errorf("create disk: %w", err)
   }

   diskOperation, err = diskOperation.Wait(ctx)
   if err != nil {
      return fmt.Errorf("wait for disk create: %w", err)
   }

   // Create the VM that uses the boot disk.
   instanceOperation, err := sdk.Services().Compute().V1().Instance().Create(ctx, &compute.CreateInstanceRequest{
      Metadata: &common.ResourceMetadata{
         ParentId: "<project_ID>",
         Name:     "my-vm",
      },
      Spec: &compute.InstanceSpec{
         Resources: &compute.ResourcesSpec{
            Platform: "<platform_name>",
            Size: &compute.ResourcesSpec_Preset{
               Preset: "<preset_name>",
            },
         },
         NetworkInterfaces: []*compute.NetworkInterfaceSpec{
            {
               Name:      "eth0",
               SubnetId:  "<subnet_ID>",
               IpAddress: &compute.IPAddress{},
            },
         },
         BootDisk: &compute.AttachedDiskSpec{
            AttachMode: compute.AttachedDiskSpec_READ_WRITE,
            Type: &compute.AttachedDiskSpec_ExistingDisk{
               ExistingDisk: &compute.ExistingDisk{
                  Id: diskOperation.ResourceID(),
               },
            },
            DeviceId: "boot-disk",
         },
      },
   })
   if err != nil {
      return fmt.Errorf("create VM: %w", err)
   }

   _, err = instanceOperation.Wait(ctx)
   if err != nil {
      return fmt.Errorf("wait for VM creation: %w", err)
   }

   return nil
}

go run <file_name>.go