go: cloud.google.com/go/container/apiv1 Index | Examples | Files

package container

import "cloud.google.com/go/container/apiv1"

Package container is an auto-generated package for the Kubernetes Engine API.

Builds and manages container-based applications, powered by the open source Kubernetes technology.

Use of Context

The ctx passed to NewClient is used for authentication requests and for creating the underlying connection, but is not used for subsequent calls. Individual methods on the client use the ctx given to them.

To close the open connection, use the Close() method.

For information about setting deadlines, reusing contexts, and more please visit pkg.go.dev/cloud.google.com/go.

Index

Examples

Package Files

cluster_manager_client.go doc.go

func DefaultAuthScopes Uses

func DefaultAuthScopes() []string

DefaultAuthScopes reports the default set of authentication scopes to use with this package.

type ClusterManagerCallOptions Uses

type ClusterManagerCallOptions struct {
    ListClusters            []gax.CallOption
    GetCluster              []gax.CallOption
    CreateCluster           []gax.CallOption
    UpdateCluster           []gax.CallOption
    UpdateNodePool          []gax.CallOption
    SetNodePoolAutoscaling  []gax.CallOption
    SetLoggingService       []gax.CallOption
    SetMonitoringService    []gax.CallOption
    SetAddonsConfig         []gax.CallOption
    SetLocations            []gax.CallOption
    UpdateMaster            []gax.CallOption
    SetMasterAuth           []gax.CallOption
    DeleteCluster           []gax.CallOption
    ListOperations          []gax.CallOption
    GetOperation            []gax.CallOption
    CancelOperation         []gax.CallOption
    GetServerConfig         []gax.CallOption
    GetJSONWebKeys          []gax.CallOption
    ListNodePools           []gax.CallOption
    GetNodePool             []gax.CallOption
    CreateNodePool          []gax.CallOption
    DeleteNodePool          []gax.CallOption
    RollbackNodePoolUpgrade []gax.CallOption
    SetNodePoolManagement   []gax.CallOption
    SetLabels               []gax.CallOption
    SetLegacyAbac           []gax.CallOption
    StartIPRotation         []gax.CallOption
    CompleteIPRotation      []gax.CallOption
    SetNodePoolSize         []gax.CallOption
    SetNetworkPolicy        []gax.CallOption
    SetMaintenancePolicy    []gax.CallOption
    ListUsableSubnetworks   []gax.CallOption
}

ClusterManagerCallOptions contains the retry settings for each method of ClusterManagerClient.

type ClusterManagerClient Uses

type ClusterManagerClient struct {

    // The call options for this service.
    CallOptions *ClusterManagerCallOptions
    // contains filtered or unexported fields
}

ClusterManagerClient is a client for interacting with Kubernetes Engine API.

Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls.

func NewClusterManagerClient Uses

func NewClusterManagerClient(ctx context.Context, opts ...option.ClientOption) (*ClusterManagerClient, error)

NewClusterManagerClient creates a new cluster manager client.

Google Kubernetes Engine Cluster Manager v1

Code:

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use client.
_ = c

func (*ClusterManagerClient) CancelOperation Uses

func (c *ClusterManagerClient) CancelOperation(ctx context.Context, req *containerpb.CancelOperationRequest, opts ...gax.CallOption) error

CancelOperation cancels the specified operation.

Code:

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.CancelOperationRequest{
    // TODO: Fill request struct fields.
}
err = c.CancelOperation(ctx, req)
if err != nil {
    // TODO: Handle error.
}

func (*ClusterManagerClient) Close Uses

func (c *ClusterManagerClient) Close() error

Close closes the connection to the API service. The user should invoke this when the client is no longer required.

func (*ClusterManagerClient) CompleteIPRotation Uses

func (c *ClusterManagerClient) CompleteIPRotation(ctx context.Context, req *containerpb.CompleteIPRotationRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

CompleteIPRotation completes master IP rotation.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.CompleteIPRotationRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.CompleteIPRotation(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) Connection Uses

func (c *ClusterManagerClient) Connection() *grpc.ClientConn

Connection returns a connection to the API service.

Deprecated.

func (*ClusterManagerClient) CreateCluster Uses

func (c *ClusterManagerClient) CreateCluster(ctx context.Context, req *containerpb.CreateClusterRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

CreateCluster creates a cluster, consisting of the specified number and type of Google Compute Engine instances.

By default, the cluster is created in the project’s default network (at https://cloud.google.com/compute/docs/networks-and-firewalls#networks).

One firewall is added for the cluster. After cluster creation, the Kubelet creates routes for each node to allow the containers on that node to communicate with all other instances in the cluster.

Finally, an entry is added to the project’s global metadata indicating which CIDR range the cluster is using.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.CreateClusterRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.CreateCluster(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) CreateNodePool Uses

func (c *ClusterManagerClient) CreateNodePool(ctx context.Context, req *containerpb.CreateNodePoolRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

CreateNodePool creates a node pool for a cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.CreateNodePoolRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.CreateNodePool(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) DeleteCluster Uses

func (c *ClusterManagerClient) DeleteCluster(ctx context.Context, req *containerpb.DeleteClusterRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

DeleteCluster deletes the cluster, including the Kubernetes endpoint and all worker nodes.

Firewalls and routes that were configured during cluster creation are also deleted.

Other Google Compute Engine resources that might be in use by the cluster, such as load balancer resources, are not deleted if they weren’t present when the cluster was initially created.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.DeleteClusterRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.DeleteCluster(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) DeleteNodePool Uses

func (c *ClusterManagerClient) DeleteNodePool(ctx context.Context, req *containerpb.DeleteNodePoolRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

DeleteNodePool deletes a node pool from a cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.DeleteNodePoolRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.DeleteNodePool(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) GetCluster Uses

func (c *ClusterManagerClient) GetCluster(ctx context.Context, req *containerpb.GetClusterRequest, opts ...gax.CallOption) (*containerpb.Cluster, error)

GetCluster gets the details of a specific cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.GetClusterRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.GetCluster(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) GetJSONWebKeys Uses

func (c *ClusterManagerClient) GetJSONWebKeys(ctx context.Context, req *containerpb.GetJSONWebKeysRequest, opts ...gax.CallOption) (*containerpb.GetJSONWebKeysResponse, error)

GetJSONWebKeys gets the public component of the cluster signing keys in JSON Web Key format. This API is not yet intended for general use, and is not available for all clusters.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.GetJSONWebKeysRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.GetJSONWebKeys(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) GetNodePool Uses

func (c *ClusterManagerClient) GetNodePool(ctx context.Context, req *containerpb.GetNodePoolRequest, opts ...gax.CallOption) (*containerpb.NodePool, error)

GetNodePool retrieves the requested node pool.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.GetNodePoolRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.GetNodePool(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) GetOperation Uses

func (c *ClusterManagerClient) GetOperation(ctx context.Context, req *containerpb.GetOperationRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

GetOperation gets the specified operation.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.GetOperationRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.GetOperation(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) GetServerConfig Uses

func (c *ClusterManagerClient) GetServerConfig(ctx context.Context, req *containerpb.GetServerConfigRequest, opts ...gax.CallOption) (*containerpb.ServerConfig, error)

GetServerConfig returns configuration info about the Google Kubernetes Engine service.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.GetServerConfigRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.GetServerConfig(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) ListClusters Uses

func (c *ClusterManagerClient) ListClusters(ctx context.Context, req *containerpb.ListClustersRequest, opts ...gax.CallOption) (*containerpb.ListClustersResponse, error)

ListClusters lists all clusters owned by a project in either the specified zone or all zones.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.ListClustersRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.ListClusters(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) ListNodePools Uses

func (c *ClusterManagerClient) ListNodePools(ctx context.Context, req *containerpb.ListNodePoolsRequest, opts ...gax.CallOption) (*containerpb.ListNodePoolsResponse, error)

ListNodePools lists the node pools for a cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.ListNodePoolsRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.ListNodePools(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) ListOperations Uses

func (c *ClusterManagerClient) ListOperations(ctx context.Context, req *containerpb.ListOperationsRequest, opts ...gax.CallOption) (*containerpb.ListOperationsResponse, error)

ListOperations lists all operations in a project in a specific zone or all zones.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.ListOperationsRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.ListOperations(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) ListUsableSubnetworks Uses

func (c *ClusterManagerClient) ListUsableSubnetworks(ctx context.Context, req *containerpb.ListUsableSubnetworksRequest, opts ...gax.CallOption) *UsableSubnetworkIterator

ListUsableSubnetworks lists subnetworks that are usable for creating clusters in a project.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"
// import "google.golang.org/api/iterator"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.ListUsableSubnetworksRequest{
    // TODO: Fill request struct fields.
}
it := c.ListUsableSubnetworks(ctx, req)
for {
    resp, err := it.Next()
    if err == iterator.Done {
        break
    }
    if err != nil {
        // TODO: Handle error.
    }
    // TODO: Use resp.
    _ = resp
}

func (*ClusterManagerClient) RollbackNodePoolUpgrade Uses

func (c *ClusterManagerClient) RollbackNodePoolUpgrade(ctx context.Context, req *containerpb.RollbackNodePoolUpgradeRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

RollbackNodePoolUpgrade rolls back a previously Aborted or Failed NodePool upgrade. This makes no changes if the last upgrade successfully completed.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.RollbackNodePoolUpgradeRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.RollbackNodePoolUpgrade(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetAddonsConfig Uses

func (c *ClusterManagerClient) SetAddonsConfig(ctx context.Context, req *containerpb.SetAddonsConfigRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetAddonsConfig sets the addons for a specific cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetAddonsConfigRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetAddonsConfig(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetLabels Uses

func (c *ClusterManagerClient) SetLabels(ctx context.Context, req *containerpb.SetLabelsRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetLabels sets labels on a cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetLabelsRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetLabels(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetLegacyAbac Uses

func (c *ClusterManagerClient) SetLegacyAbac(ctx context.Context, req *containerpb.SetLegacyAbacRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetLegacyAbac enables or disables the ABAC authorization mechanism on a cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetLegacyAbacRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetLegacyAbac(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetLocations Uses

func (c *ClusterManagerClient) SetLocations(ctx context.Context, req *containerpb.SetLocationsRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetLocations sets the locations for a specific cluster. Deprecated. Use projects.locations.clusters.update (at https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters/update) instead.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetLocationsRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetLocations(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetLoggingService Uses

func (c *ClusterManagerClient) SetLoggingService(ctx context.Context, req *containerpb.SetLoggingServiceRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetLoggingService sets the logging service for a specific cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetLoggingServiceRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetLoggingService(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetMaintenancePolicy Uses

func (c *ClusterManagerClient) SetMaintenancePolicy(ctx context.Context, req *containerpb.SetMaintenancePolicyRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetMaintenancePolicy sets the maintenance policy for a cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetMaintenancePolicyRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetMaintenancePolicy(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetMasterAuth Uses

func (c *ClusterManagerClient) SetMasterAuth(ctx context.Context, req *containerpb.SetMasterAuthRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetMasterAuth sets master auth materials. Currently supports changing the admin password or a specific cluster, either via password generation or explicitly setting the password.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetMasterAuthRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetMasterAuth(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetMonitoringService Uses

func (c *ClusterManagerClient) SetMonitoringService(ctx context.Context, req *containerpb.SetMonitoringServiceRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetMonitoringService sets the monitoring service for a specific cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetMonitoringServiceRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetMonitoringService(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetNetworkPolicy Uses

func (c *ClusterManagerClient) SetNetworkPolicy(ctx context.Context, req *containerpb.SetNetworkPolicyRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetNetworkPolicy enables or disables Network Policy for a cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetNetworkPolicyRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetNetworkPolicy(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetNodePoolAutoscaling Uses

func (c *ClusterManagerClient) SetNodePoolAutoscaling(ctx context.Context, req *containerpb.SetNodePoolAutoscalingRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetNodePoolAutoscaling sets the autoscaling settings for the specified node pool.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetNodePoolAutoscalingRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetNodePoolAutoscaling(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetNodePoolManagement Uses

func (c *ClusterManagerClient) SetNodePoolManagement(ctx context.Context, req *containerpb.SetNodePoolManagementRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetNodePoolManagement sets the NodeManagement options for a node pool.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetNodePoolManagementRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetNodePoolManagement(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) SetNodePoolSize Uses

func (c *ClusterManagerClient) SetNodePoolSize(ctx context.Context, req *containerpb.SetNodePoolSizeRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

SetNodePoolSize sets the size for a specific node pool.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.SetNodePoolSizeRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.SetNodePoolSize(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) StartIPRotation Uses

func (c *ClusterManagerClient) StartIPRotation(ctx context.Context, req *containerpb.StartIPRotationRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

StartIPRotation starts master IP rotation.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.StartIPRotationRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.StartIPRotation(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) UpdateCluster Uses

func (c *ClusterManagerClient) UpdateCluster(ctx context.Context, req *containerpb.UpdateClusterRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

UpdateCluster updates the settings of a specific cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.UpdateClusterRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.UpdateCluster(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) UpdateMaster Uses

func (c *ClusterManagerClient) UpdateMaster(ctx context.Context, req *containerpb.UpdateMasterRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

UpdateMaster updates the master for a specific cluster.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.UpdateMasterRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.UpdateMaster(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

func (*ClusterManagerClient) UpdateNodePool Uses

func (c *ClusterManagerClient) UpdateNodePool(ctx context.Context, req *containerpb.UpdateNodePoolRequest, opts ...gax.CallOption) (*containerpb.Operation, error)

UpdateNodePool updates the version and/or image type for the specified node pool.

Code:

// import containerpb "google.golang.org/genproto/googleapis/container/v1"

ctx := context.Background()
c, err := container.NewClusterManagerClient(ctx)
if err != nil {
    // TODO: Handle error.
}

req := &containerpb.UpdateNodePoolRequest{
    // TODO: Fill request struct fields.
}
resp, err := c.UpdateNodePool(ctx, req)
if err != nil {
    // TODO: Handle error.
}
// TODO: Use resp.
_ = resp

type UsableSubnetworkIterator Uses

type UsableSubnetworkIterator struct {

    // Response is the raw response for the current page.
    // It must be cast to the RPC response type.
    // Calling Next() or InternalFetch() updates this value.
    Response interface{}

    // InternalFetch is for use by the Google Cloud Libraries only.
    // It is not part of the stable interface of this package.
    //
    // InternalFetch returns results from a single call to the underlying RPC.
    // The number of results is no greater than pageSize.
    // If there are no more results, nextPageToken is empty and err is nil.
    InternalFetch func(pageSize int, pageToken string) (results []*containerpb.UsableSubnetwork, nextPageToken string, err error)
    // contains filtered or unexported fields
}

UsableSubnetworkIterator manages a stream of *containerpb.UsableSubnetwork.

func (*UsableSubnetworkIterator) Next Uses

func (it *UsableSubnetworkIterator) Next() (*containerpb.UsableSubnetwork, error)

Next returns the next result. Its second return value is iterator.Done if there are no more results. Once Next returns Done, all subsequent calls will return Done.

func (*UsableSubnetworkIterator) PageInfo Uses

func (it *UsableSubnetworkIterator) PageInfo() *iterator.PageInfo

PageInfo supports pagination. See the google.golang.org/api/iterator package for details.

Package container imports 20 packages (graph) and is imported by 4 packages. Updated 2020-11-19. Refresh now. Tools for package owners.