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 Google Container Engine API.

NOTE: This package is in alpha. It is not stable, and is likely to change.

The Google Kubernetes Engine API is used for building and managing container based applications, powered by the open source Kubernetes technology.

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
    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
}

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 Google Container 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 Container 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:

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 the client's connection to the API service.

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 /compute/docs/networks-and-firewalls#networks).

One firewall is added for the cluster. After cluster creation, the cluster 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 is being used by the cluster.

Code:

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:

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 (e.g. load balancer resources) will not be deleted if they weren't present at the initial create time.

Code:

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:

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:

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) GetNodePool Uses

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

GetNodePool retrieves the node pool requested.

Code:

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:

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 Container Engine service.

Code:

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:

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:

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:

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) RollbackNodePoolUpgrade Uses

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

RollbackNodePoolUpgrade roll back the previously Aborted or Failed NodePool upgrade. This will be an no-op if the last upgrade successfully completed.

Code:

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 of a specific cluster.

Code:

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:

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:

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 of a specific cluster.

Code:

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 of a specific cluster.

Code:

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:

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 used to set master auth materials. Currently supports :- Changing the admin password of a specific cluster. This can be either via password generation or explicitly set the password.

Code:

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 of a specific cluster.

Code:

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/Disables Network Policy for a cluster.

Code:

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 of a specific node pool.

Code:

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:

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 of a specific node pool.

Code:

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 start master IP rotation.

Code:

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:

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 of a specific cluster.

Code:

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 of a specific node pool.

Code:

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

Package container imports 10 packages (graph). Updated 2018-12-07. Refresh now. Tools for package owners.