or run

tessl search
Log in

Version

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
golangpkg:golang/cloud.google.com/go/compute@v1.53.0

docs

clients

disks.mdinstances.mdload-balancing.mdnetworks.mdoperations.mdother-clients.mdregional.mdsecurity.mdstorage.md
index.mdmetadata.mdtypes.md
tile.json

tessl/golang-cloud-google-com--go--compute

tessl install tessl/golang-cloud-google-com--go--compute@1.53.0

Go client library for Google Cloud Compute Engine API providing programmatic access to manage virtual machines, disks, networks, and other compute resources

regional.mddocs/clients/

Regional Clients

Regional clients manage region-scoped resources in Google Compute Engine. Many global resource types have regional counterparts for improved locality, reduced latency, and regional high-availability configurations.

Overview

Regional resources are scoped to a specific region rather than being global or zone-specific. They provide:

  • Regional availability: Resources remain available if a zone fails
  • Lower latency: Resources located closer to users in specific regions
  • Regional load balancing: Region-scoped load balancer configurations
  • Compliance: Meet data residency requirements

Regional Instance Management

Region Instance Group Managers Client

func NewRegionInstanceGroupManagersRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionInstanceGroupManagersClient, error)

Manages regional managed instance groups for multi-zone deployments within a region.

Key operations: Create, update, and manage regional MIGs; configure autoscaling; perform rolling updates.

Example:

import (
    "context"
    compute "cloud.google.com/go/compute/apiv1"
    "cloud.google.com/go/compute/apiv1/computepb"
    "google.golang.org/protobuf/proto"
)

ctx := context.Background()
client, err := compute.NewRegionInstanceGroupManagersRESTClient(ctx)
if err != nil {
    // handle error
}
defer client.Close()

insertReq := &computepb.InsertRegionInstanceGroupManagerRequest{
    Project: "my-project",
    Region:  "us-central1",
    InstanceGroupManagerResource: &computepb.InstanceGroupManager{
        Name:             proto.String("regional-mig"),
        BaseInstanceName: proto.String("instance"),
        TargetSize:       proto.Int32(3),
        InstanceTemplate: proto.String("projects/my-project/global/instanceTemplates/my-template"),
        DistributionPolicy: &computepb.DistributionPolicy{
            Zones: []*computepb.DistributionPolicyZoneConfiguration{
                {Zone: proto.String("zones/us-central1-a")},
                {Zone: proto.String("zones/us-central1-b")},
                {Zone: proto.String("zones/us-central1-c")},
            },
        },
    },
}
op, err := client.Insert(ctx, insertReq)

Region Instance Groups Client

func NewRegionInstanceGroupsRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionInstanceGroupsClient, error)

Manages regional instance groups.

Region Instances Client

func NewRegionInstancesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionInstancesClient, error)

Performs operations on instances at the regional scope.

Region Instance Templates Client

func NewRegionInstanceTemplatesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionInstanceTemplatesClient, error)

Manages region-specific instance templates.

Regional Storage

Region Disks Client

func NewRegionDisksRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionDisksClient, error)

Manages regional persistent disks that replicate across zones within a region for high availability.

Example:

client, err := compute.NewRegionDisksRESTClient(ctx)
if err != nil {
    // handle error
}
defer client.Close()

insertReq := &computepb.InsertRegionDiskRequest{
    Project: "my-project",
    Region:  "us-central1",
    DiskResource: &computepb.Disk{
        Name:   proto.String("regional-disk"),
        SizeGb: proto.Int64(200),
        Type:   proto.String("regions/us-central1/diskTypes/pd-ssd"),
        ReplicaZones: []string{
            "projects/my-project/zones/us-central1-a",
            "projects/my-project/zones/us-central1-b",
        },
    },
}
op, err := client.Insert(ctx, insertReq)

Region Disk Types Client

func NewRegionDiskTypesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionDiskTypesClient, error)

Lists available regional disk types.

Region Instant Snapshots Client

func NewRegionInstantSnapshotsRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionInstantSnapshotsClient, error)

Manages regional instant snapshots.

Regional Load Balancing

Region Backend Services Client

func NewRegionBackendServicesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionBackendServicesClient, error)

Manages regional backend services for regional load balancers.

Region Health Checks Client

func NewRegionHealthChecksRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionHealthChecksClient, error)

Manages regional health checks.

Region Health Check Services Client

func NewRegionHealthCheckServicesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionHealthCheckServicesClient, error)

Manages regional health check services.

Region URL Maps Client

func NewRegionUrlMapsRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionUrlMapsClient, error)

Manages regional URL maps for HTTP(S) load balancing.

Region Target HTTP Proxies Client

func NewRegionTargetHttpProxiesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionTargetHttpProxiesClient, error)

Manages regional HTTP target proxies.

Region Target HTTPS Proxies Client

func NewRegionTargetHttpsProxiesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionTargetHttpsProxiesClient, error)

Manages regional HTTPS target proxies.

Region Target TCP Proxies Client

func NewRegionTargetTcpProxiesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionTargetTcpProxiesClient, error)

Manages regional TCP target proxies.

Regional Networking

Region Network Endpoint Groups Client

func NewRegionNetworkEndpointGroupsRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionNetworkEndpointGroupsClient, error)

Manages regional network endpoint groups.

Regional Network Firewall Policies Client

func NewRegionalNetworkFirewallPoliciesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionalNetworkFirewallPoliciesClient, error)

Manages regional network firewall policies.

Regional Security

Region Security Policies Client

func NewRegionSecurityPoliciesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionSecurityPoliciesClient, error)

Manages regional Cloud Armor security policies.

Region SSL Certificates Client

func NewRegionSslCertificatesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionSslCertificatesClient, error)

Manages regional SSL certificates.

Region SSL Policies Client

func NewRegionSslPoliciesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionSslPoliciesClient, error)

Manages regional SSL policies.

Regional Autoscaling

Region Autoscalers Client

func NewRegionAutoscalersRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionAutoscalersClient, error)

Manages regional autoscalers for managed instance groups.

Example:

client, err := compute.NewRegionAutoscalersRESTClient(ctx)
if err != nil {
    // handle error
}
defer client.Close()

insertReq := &computepb.InsertRegionAutoscalerRequest{
    Project: "my-project",
    Region:  "us-central1",
    AutoscalerResource: &computepb.Autoscaler{
        Name:   proto.String("regional-autoscaler"),
        Target: proto.String("projects/my-project/regions/us-central1/instanceGroupManagers/regional-mig"),
        AutoscalingPolicy: &computepb.AutoscalingPolicy{
            MinNumReplicas: proto.Int32(2),
            MaxNumReplicas: proto.Int32(10),
            CpuUtilization: &computepb.AutoscalingPolicyCpuUtilization{
                UtilizationTarget: proto.Float64(0.6),
            },
        },
    },
}
op, err := client.Insert(ctx, insertReq)

Regional Commitments

Region Commitments Client

func NewRegionCommitmentsRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionCommitmentsClient, error)

Manages committed use discounts at the regional level.

Regional Notifications

Region Notification Endpoints Client

func NewRegionNotificationEndpointsRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionNotificationEndpointsClient, error)

Manages regional notification endpoints.

Regional Information

Regions Client

func NewRegionsRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionsClient, error)

Lists available GCP regions and their properties.

Example:

import "google.golang.org/api/iterator"

client, err := compute.NewRegionsRESTClient(ctx)
if err != nil {
    // handle error
}
defer client.Close()

listReq := &computepb.ListRegionsRequest{
    Project: "my-project",
}
it := client.List(ctx, listReq)
for {
    region, err := it.Next()
    if err == iterator.Done {
        break
    }
    if err != nil {
        // handle error
    }
    fmt.Printf("Region: %s, Status: %s, Zones: %v\n",
        *region.Name, *region.Status, region.Zones)
}

Region Zones Client

func NewRegionZonesRESTClient(ctx context.Context, opts ...option.ClientOption) (*RegionZonesClient, error)

Provides information about zones within regions.

Complete List of Regional Clients

The package includes the following regional clients:

  • RegionAutoscalersClient - Regional autoscalers
  • RegionBackendServicesClient - Regional backend services
  • RegionCommitmentsClient - Regional committed use discounts
  • RegionDiskTypesClient - Regional disk types
  • RegionDisksClient - Regional persistent disks
  • RegionHealthCheckServicesClient - Regional health check services
  • RegionHealthChecksClient - Regional health checks
  • RegionInstanceGroupManagersClient - Regional managed instance groups
  • RegionInstanceGroupsClient - Regional instance groups
  • RegionInstanceTemplatesClient - Regional instance templates
  • RegionInstancesClient - Regional instance operations
  • RegionInstantSnapshotsClient - Regional instant snapshots
  • RegionNetworkEndpointGroupsClient - Regional network endpoint groups
  • RegionNotificationEndpointsClient - Regional notification endpoints
  • RegionSecurityPoliciesClient - Regional security policies
  • RegionSslCertificatesClient - Regional SSL certificates
  • RegionSslPoliciesClient - Regional SSL policies
  • RegionTargetHttpProxiesClient - Regional HTTP proxies
  • RegionTargetHttpsProxiesClient - Regional HTTPS proxies
  • RegionTargetTcpProxiesClient - Regional TCP proxies
  • RegionUrlMapsClient - Regional URL maps
  • RegionZonesClient - Regional zone information
  • RegionalNetworkFirewallPoliciesClient - Regional network firewall policies
  • RegionsClient - Region listing and information

Common Patterns

Pattern 1: Regional vs Global Selection

Choose between regional and global resources based on requirements:

// For global accessibility
globalBackendClient, _ := compute.NewBackendServicesRESTClient(ctx)

// For regional high availability
regionalBackendClient, _ := compute.NewRegionBackendServicesRESTClient(ctx)

Pattern 2: Multi-Zone Distribution

Regional resources often support multi-zone distribution:

// Regional disk with replica zones
disk := &computepb.Disk{
    Name:   proto.String("ha-disk"),
    Region: proto.String("us-central1"),
    ReplicaZones: []string{
        "projects/my-project/zones/us-central1-a",
        "projects/my-project/zones/us-central1-b",
    },
}

// Regional MIG with distribution policy
mig := &computepb.InstanceGroupManager{
    Name:   proto.String("ha-mig"),
    Region: proto.String("us-central1"),
    DistributionPolicy: &computepb.DistributionPolicy{
        Zones: []*computepb.DistributionPolicyZoneConfiguration{
            {Zone: proto.String("zones/us-central1-a")},
            {Zone: proto.String("zones/us-central1-b")},
            {Zone: proto.String("zones/us-central1-f")},
        },
    },
}

Pattern 3: Regional Load Balancer Setup

Configure a complete regional load balancer:

// 1. Create regional backend service
backendClient, _ := compute.NewRegionBackendServicesRESTClient(ctx)
backendOp, _ := backendClient.Insert(ctx, &computepb.InsertRegionBackendServiceRequest{
    Project: "my-project",
    Region:  "us-central1",
    BackendServiceResource: &computepb.BackendService{
        Name:     proto.String("regional-backend"),
        Protocol: proto.String("HTTP"),
        // ... backend configuration
    },
})
backendOp.Wait(ctx)

// 2. Create regional URL map
urlMapClient, _ := compute.NewRegionUrlMapsRESTClient(ctx)
urlMapOp, _ := urlMapClient.Insert(ctx, &computepb.InsertRegionUrlMapRequest{
    Project: "my-project",
    Region:  "us-central1",
    UrlMapResource: &computepb.UrlMap{
        Name:           proto.String("regional-url-map"),
        DefaultService: proto.String("projects/my-project/regions/us-central1/backendServices/regional-backend"),
    },
})
urlMapOp.Wait(ctx)

// 3. Create regional target proxy
proxyClient, _ := compute.NewRegionTargetHttpProxiesRESTClient(ctx)
proxyOp, _ := proxyClient.Insert(ctx, &computepb.InsertRegionTargetHttpProxyRequest{
    Project: "my-project",
    Region:  "us-central1",
    TargetHttpProxyResource: &computepb.TargetHttpProxy{
        Name:   proto.String("regional-proxy"),
        UrlMap: proto.String("projects/my-project/regions/us-central1/urlMaps/regional-url-map"),
    },
})
proxyOp.Wait(ctx)

Request Type Pattern

Regional resources use region-scoped request types:

// Regional request pattern
type InsertRegionDiskRequest struct {
    DiskResource *Disk
    Project      string
    Region       string  // Region instead of Zone
    RequestId    *string
    SourceImage  *string
}

// Compare with zonal request
type InsertDiskRequest struct {
    DiskResource *Disk
    Project      string
    Zone         string  // Zone-specific
    RequestId    *string
    SourceImage  *string
}