rubrikcdm

func (*Credentials) AWSAccountSummary ¶

func (c *Credentials) AWSAccountSummary(awsAccountName string, timeout ...int) (*CurrentAWSAccountID, error)

AWSAccountSummary retrieves all information from an AWS Native Account.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	awasAccountName := "Go SDK"

	awsSummary, err := rubrik.AWSAccountSummary(awasAccountName)
	if err != nil {
		log.Fatal(err)
	}

}

Output:

func (*Credentials) AWSS3CloudOn ¶

func (c *Credentials) AWSS3CloudOn(archiveName, vpcID, subnetID, securityGroupID string, timeout ...int) (*CloudOn, error)

AWSS3CloudOn provides the ability to convert a vSphere virtual machines snapshot, an archived snapshot, or a replica into an Amazon Machine Image (AMI) and then launch that AMI into an Elastic Compute Cloud (EC2) instance on an Amazon Virtual Private Cloud (VPC).

The function will return one of the following:

• No change required. The '{archiveName}' archive location is already configured for CloudOn.

• The full API response for PATCH /internal/archive/object_store.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	archiveName := "AWS:S3:GoSDK"
	vpcID := "vpc-01234567"
	subnetID := "subnet-01234567"
	securityGroupID := "sg-01234567"

	awsCloudOn, err := rubrik.AWSS3CloudOn(archiveName, vpcID, subnetID, securityGroupID)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) AWSS3CloudOutKMS ¶

func (c *Credentials) AWSS3CloudOutKMS(awsBucketName, storageClass, archiveName, awsRegion, awsAccessKey, awsSecretKey, kmsMasterKeyID string, timeout ...int) (interface{}, error)

AWSS3CloudOutKMS configures a new AWS S3 archive target using a AWS KMS Master Key ID for encryption.

Valid "awsRegion" choices are:

ap-south-1,ap-northeast-3, ap-northeast-2, ap-southeast-1, ap-southeast-2, ap-northeast-1, ca-central-1, cn-north-1, cn-northwest-1, eu-central-1, eu-west-1,
eu-west-2, eu-west-3, us-west-1, us-east-1, us-east-2, and us-west-2.

Valid "storageClass" choices are:

standard, standard_ia, and reduced_redundancy

The function will return one of the following:

• No change required. The '{archiveName}' archive location is already configured on the Rubrik cluster.

• The full API response for POST /internal/archive/object_store/{archiveID}

package main

import (
	"log"
	"os"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	awsBucket := "rubrikgosdk"
	storageClass := "standard"
	archiveName := "AWS:S3:GoSDK"
	awsRegion := "us-east-1"
	awsAccessKey := os.Getenv("AWS_ACCESS_KEY_ID")
	awsSecretKey := os.Getenv("AWS_SECRET_ACCESS_KEY")
	kmsMasterKeyID := os.Getenv("AWS_MASTER_KEY_ID")

	awsCloudOut, err := rubrik.AWSS3CloudOutKMS(awsBucket, storageClass, archiveName, awsRegion, awsAccessKey, awsSecretKey, kmsMasterKeyID)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) AWSS3CloudOutRSA ¶

func (c *Credentials) AWSS3CloudOutRSA(awsBucketName, storageClass, archiveName, awsRegion, awsAccessKey, awsSecretKey, rsaKey string, timeout ...int) (interface{}, error)

AWSS3CloudOutRSA configures a new AWS S3 archive target using a RSA Key for encryption.

Valid "awsRegion" choices are:

ap-south-1,ap-northeast-3, ap-northeast-2, ap-southeast-1, ap-southeast-2, ap-northeast-1, ca-central-1, cn-north-1, cn-northwest-1, eu-central-1, eu-west-1,
eu-west-2, eu-west-3, us-west-1, us-east-1, us-east-2, and us-west-2.

Valid "storageClass" choices are:

standard, standard_ia, and reduced_redundancy

The function will return one of the following:

• No change required. The '{archiveName}' archive location is already configured on the Rubrik cluster.

• The full API response for POST /internal/archive/object_store.

package main

import (
	"io/ioutil"
	"log"
	"os"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	awsBucket := "rubrikgosdk"
	storageClass := "standard"
	archiveName := "AWS:S3:GoSDK"
	awsRegion := "us-east-1"
	awsAccessKey := os.Getenv("AWS_ACCESS_KEY_ID")
	awsSecretKey := os.Getenv("AWS_SECRET_ACCESS_KEY")
	readRSAKey, _ := ioutil.ReadFile("rsa_key.pem")
	rsaKey := string(readRSAKey)

	awsCloudOut, err := rubrik.AWSS3CloudOutRSA(awsBucket, storageClass, archiveName, awsRegion, awsAccessKey, awsSecretKey, rsaKey)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) AddAWSNativeAccount ¶

func (c *Credentials) AddAWSNativeAccount(awsAccountName, awsAccessKey, awsSecretKey string, awsRegions []string, regionalBoltNetworkConfigs interface{}, timeout ...int) (interface{}, error)

AddAWSNativeAccount enables the management and protection of Amazon Elastic Compute Cloud (Amazon EC2) instances. The "regionalBoltNetworkConfigs" should be a list of dictionaries in the following format:

usEast1 := map[string]string{}
usEast1["region"] = "us-east-1"
usEast1["region"] = "us-east-1"
usEast1["region"] = "us-east-1"
usEast1["vNetId"] = "vpc-11a44968"
usEast1["subnetId"] = "subnet-3ac58e06"
usEast1["securityGroupId"] = "sg-9ba90ee5"

regionalBoltNetworkConfigs := []interface{}{usEast1}

Valid "awsRegion" choices are:

ap-south-1,ap-northeast-3, ap-northeast-2, ap-southeast-1, ap-southeast-2, ap-northeast-1, ca-central-1, cn-north-1, cn-northwest-1, eu-central-1, eu-west-1,
eu-west-2, eu-west-3, us-west-1, us-east-1, us-east-2, and us-west-2.

The function will return one of the following:

No change required. Cloud native source with access key '{awsAccessKey}' is already configured on the Rubrik cluster.

//

The full API response for POST /internal/aws/account.

package main

import (
	"log"
	"os"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	awsAccountName := "GO SDK Demo" // This is the name that will be displayed in the Rubrik UI
	awsAccessKey := os.Getenv("AWS_ACCESS_KEY_ID")
	awsSecretKey := os.Getenv("AWS_SECRET_ACCESS_KEY")
	awsRegions := []string{"us-east-1"}

	usEast1 := map[string]string{}
	usEast1["region"] = "us-east-1"
	usEast1["vNetId"] = "vpc-01234567"
	usEast1["subnetId"] = "subnet-01234567"
	usEast1["securityGroupId"] = "sg-01234567"
	boltConfig := []interface{}{usEast1}

	addAWSNative, err := rubrik.AddAWSNativeAccount(awsAccountName, awsAccessKey, awsSecretKey, awsRegions, boltConfig)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) AddvCenter ¶

func (c *Credentials) AddvCenter(vCenterIP, vCenterUsername, vCenterPassword string, vmLinking bool, timeout ...int) (interface{}, error)

AddvCenter connects to the Rubrik cluster to a new vCenter instance.

The function will return one of the following:

No change required. The vCenter '{vcenterIP}' has already been added to the Rubrik cluster.

The full API response for POST /v1/VMware/vcenter

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	vCenterIP := "vcsa.rubrikgosdk.lab"
	vCenterUsername := "go"
	vCenterPassword := "sdk"
	vmLinking := true

	addVcenter, err := rubrik.AddvCenter(vCenterIP, vCenterUsername, vCenterPassword, vmLinking)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) AddvCenterWithCert ¶

func (c *Credentials) AddvCenterWithCert(vCenterIP, vCenterUsername, vCenterPassword, caCertificate string, vmLinking bool, timeout ...int) (interface{}, error)

AddvCenterWithCert connects to the Rubrik cluster to a new vCenter instance using a CA certificate.

The function will return one of the following:

No change required. The vCenter '{vcenterIP}' has already been added to the Rubrik cluster.

The full API response for POST /v1/VMware/vcenter

package main

import (
	"io/ioutil"
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	vCenterIP := "vcsa.rubrikgosdk.lab"
	vCenterUsername := "go"
	vCenterPassword := "sdk"
	readcaCertificate, _ := ioutil.ReadFile("ca_cert")
	caCert := string(readcaCertificate)
	vmLinking := true

	addVcenterWithCert, err := rubrik.AddvCenterWithCert(vCenterIP, vCenterUsername, vCenterPassword, caCert, vmLinking)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) AssignSLA ¶

func (c *Credentials) AssignSLA(objectName, objectType, slaName string, timeout ...int) (*StatusCode, error)

AssignSLA adds the "objectName" to the "slaName". vmware and ahv are the only supported "objectType". To exclude the object from all SLA assignments use "do not protect" as the "slaName". To assign the selected object to the SLA of the next higher level object, use "clear" as the "slaName".

The function will return one of the following:

No change required. The vSphere VM '{objectName}' is already assigned to the '{slaName}' SLA Domain.

The full API response for POST /internal/sla_domain/{slaID}/assign.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	objectName := "vm01"
	slaName := "Bronze"

	assignSLA, err := rubrik.AssignSLA(objectName, "vmware", slaName)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) AzureCloudOn ¶

func (c *Credentials) AzureCloudOn(archiveName, container, storageAccountName, applicationID, applicationKey, directoryID, region, virtualNetworkID, subnetName, securityGroupID string, timeout ...int) (*CloudOn, error)

AzureCloudOn provides the ability to convert a snapshot, archived snapshot, or replica into a Virtual Hard Disk (VHD). This enables the instantiation of the associated virtual machine on the Microsoft Azure cloud platform.

Valid "region" choices are:

westus, westus2, centralus, eastus, eastus2, northcentralus, southcentralus, westcentralus, canadacentral, canadaeast, brazilsouth,
northeurope, westeurope, uksouth, ukwest, eastasia, southeastasia, japaneast, japanwest, australiaeast, australiasoutheast, centralindia,
southindia, westindia, koreacentral, koreasouth

The function will return one of the following:

• No change required. The '{archiveName}' archive location is already configured for CloudOn.

• The full API response for PATCH /internal/archive/object_store.

package main

import (
	"log"
	"os"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	archiveName := "Azure:GoSDK"
	container := "gosdk"
	storageAccountName := "rubrikgosdk"
	applicationID := os.Getenv("AZURE_APP_ID")
	applicationKey := os.Getenv("AZURE_APP_KEY")

	directoryID := os.Getenv("AZURE_DIRECTORY_ID")
	region := "westus2"
	virtualNetworkID := os.Getenv("AZURE_VNET_ID")
	subnetName := os.Getenv("AZURE_SUBNET")
	securityGroupID := os.Getenv("AZURE_SECURITY_GROUP")

	azureCloudOn, err := rubrik.AzureCloudOn(archiveName, container, storageAccountName, applicationID, applicationKey, directoryID, region, virtualNetworkID, subnetName, securityGroupID)
	if err != nil {
		log.Fatal(err)
	}

}

Output:

func (*Credentials) AzureCloudOut ¶

func (c *Credentials) AzureCloudOut(container, azureAccessKey, storageAccountName, archiveName, instanceType, rsaKey string, timeout ...int) (interface{}, error)

AzureCloudOut configures a new Azure archive target.

Valid "instanceType" choices are:

default, china, germany, and government

The function will return one of the following:

• No change required. The '{archiveName}' archive location is already configured on the Rubrik cluster.

• The full API response for POST /internal/archive/object_store.

package main

import (
	"io/ioutil"
	"log"
	"os"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	container := "gosdk"
	azureAccessKey := os.Getenv("AZURE_ACCESS_KEY")
	storageAccountName := "rubrikgosdk"
	archiveName := "Azure:gosdk"
	instanceType := "default"
	readRSAKey, _ := ioutil.ReadFile("rsa_key.pem")
	rsaKey := string(readRSAKey)

	azureCloudOut, err := rubrik.AzureCloudOut(container, azureAccessKey, storageAccountName, archiveName, instanceType, rsaKey)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) BeginManagedVolumeSnapshot ¶

func (c *Credentials) BeginManagedVolumeSnapshot(name string, timeout ...int) (*StatusCode, error)

BeginManagedVolumeSnapshot opens a managed volume for writes. All writes to the managed volume until the snapshot is ended will be part of its snapshot.

The function will return one of the following:

No change required. The Managed Volume '{name}' is already in a writeable state.

The full API response for POST /internal/managed_volume/{managedVolumeID}/begin_snapshot

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	mvName := "GoSDK"

	beginMV, err := rubrik.BeginManagedVolumeSnapshot(mvName)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) Bootstrap ¶

func (c *Credentials) Bootstrap(clusterName, adminEmail, adminPassword, managementGateway, managementSubnetMask string, dnsSearchDomains []string, dnsNameServers []string, ntpServers map[string]interface{}, nodeConfig map[string]string, enableEncryption, waitForCompletion bool, timeout ...int) (interface{}, error)

Bootstrap will complete the bootstrap process for a Rubrik cluster and requires a single node to have it's management interface configured. You will also need to use Connect() with the "username" and "password" set to blank strings. The "nodeConfig" should be in a {nodeName: nodeManagementIP} format. To monitor the bootstrap process and wait for the process to complete, set "waitForCompletion" to true.

The function will return one of the following:

The full API response for POST /internal/cluster/me/bootstrap?request_id={requestID} (waitForCompletion is set to true)

The full API response for POST /internal/cluster/me/bootstrap (waitForCompletion is set to false)

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {

	bootstrapNode := "192.168.101.100"
	rubrik := rubrikcdm.Connect(bootstrapNode, "", "")

	clusterName := "Go-SDK"
	adminEmail := "gosdk@rubrikgosdk.lab"
	adminPassword := "RubrikGoSDK"
	managementGateway := "192.168.101.1"
	managementSubnetMask := "255.255.255.0"
	dnsSearchDomain := []string{"rubrikgosdk.lab"}
	dnsNameServers := []string{"192.168.100.5", "192.168.100.6"}
	ntpServers := map[string]interface{}{}
	ntpServers["ntpServer1"] = map[string]interface{}{}
	ntpServers["ntpServer1"].(map[string]interface{})["IP"] = "192.168.100.5"
	ntpServers["ntpServer2"] = map[string]interface{}{}
	ntpServers["ntpServer2"].(map[string]interface{})["IP"] = "192.168.100.6"
	enableEncryption := true // set to false for a Cloud Cluster
	waitForCompletion := true

	nodeConfig := map[string]string{}
	nodeConfig["RVM1234567890"] = bootstrapNode
	nodeConfig["RVM1234567891"] = "192.168.101.101"
	nodeConfig["RVM1234567892"] = "192.168.101.102"
	nodeConfig["RVM1234567893"] = "192.168.101.103"

	bootstrap, err := rubrik.Bootstrap(clusterName, adminEmail, adminPassword, managementGateway, managementSubnetMask, dnsSearchDomain, dnsNameServers, ntpServers, nodeConfig, enableEncryption, waitForCompletion)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {

	bootstrapNode := "192.168.101.100"
	rubrik := rubrikcdm.Connect(bootstrapNode, "", "")

	clusterName := "Go-SDK"
	adminEmail := "gosdk@rubrikgosdk.lab"
	adminPassword := "RubrikGoSDK"
	managementGateway := "192.168.101.1"
	managementSubnetMask := "255.255.255.0"
	dnsSearchDomain := []string{"rubrikgosdk.lab"}
	dnsNameServers := []string{"192.168.100.5", "192.168.100.6"}
	ntpServers := map[string]interface{}{}
	ntpServers["ntpServer1"] = map[string]interface{}{}
	ntpServers["ntpServer1"].(map[string]interface{})["IP"] = "192.168.100.5"
	ntpServers["ntpServer1"].(map[string]interface{})["key"] = "key-material-for-ntpserver-1"
	ntpServers["ntpServer1"].(map[string]interface{})["keyId"] = 0
	ntpServers["ntpServer1"].(map[string]interface{})["keyType"] = "MD5"
	ntpServers["ntpServer2"] = map[string]interface{}{}
	ntpServers["ntpServer2"].(map[string]interface{})["IP"] = "192.168.100.6"
	ntpServers["ntpServer2"].(map[string]interface{})["keyId"] = 1
	ntpServers["ntpServer2"].(map[string]interface{})["key"] = "key-material-for-ntpserver-2"
	ntpServers["ntpServer2"].(map[string]interface{})["keyType"] = "SHA1"
	enableEncryption := true // set to false for a Cloud Cluster
	waitForCompletion := true

	nodeConfig := map[string]string{}
	nodeConfig["RVM1234567890"] = bootstrapNode
	nodeConfig["RVM1234567891"] = "192.168.101.101"
	nodeConfig["RVM1234567892"] = "192.168.101.102"
	nodeConfig["RVM1234567893"] = "192.168.101.103"

	bootstrap, err := rubrik.Bootstrap(clusterName, adminEmail, adminPassword, managementGateway, managementSubnetMask, dnsSearchDomain, dnsNameServers, ntpServers, nodeConfig, enableEncryption, waitForCompletion)
	if err != nil {
		log.Fatal(err)
	}

}

Output:

func (*Credentials) BootstrapCcesAws ¶ added in v1.2.0

func (c *Credentials) BootstrapCcesAws(clusterName, adminEmail, adminPassword, managementGateway, managementSubnetMask string, dnsSearchDomains []string, dnsNameServers []string, ntpServers map[string]interface{}, nodeConfig map[string]string, enableEncryption bool, bucketName string, enableImmutability bool, waitForCompletion bool, timeout ...int) (interface{}, error)

BootstrapCcesAws will complete the bootstrap process for a Rubrik Cloud Cluster Elastic Storage (CCES) on AWS. You will also need to use Connect() with the "username" and "password" set to blank strings. The "nodeConfig" should be in a {nodeName: nodeManagementIP} format. To monitor the bootstrap process and wait for the process to complete, set "waitForCompletion" to true.

The function will return one of the following:

The full API response for POST /internal/cluster/me/bootstrap?request_id={requestID} (waitForCompletion is set to true)

The full API response for POST /internal/cluster/me/bootstrap (waitForCompletion is set to false)

func (*Credentials) BootstrapCcesAzure ¶ added in v1.2.0

func (c *Credentials) BootstrapCcesAzure(clusterName, adminEmail, adminPassword, managementGateway, managementSubnetMask string, dnsSearchDomains []string, dnsNameServers []string, ntpServers map[string]interface{}, nodeConfig map[string]string, enableEncryption bool, connectionString string, containerName string, enableImmutability bool, waitForCompletion bool, timeout ...int) (interface{}, error)

BootstrapCcesAzure will complete the bootstrap process for a Rubrik Cloud Cluster Elastic Storage (CCES) on Azure. You will also need to use Connect() with the "username" and "password" set to blank strings. The "nodeConfig" should be in a {nodeName: nodeManagementIP} format. To monitor the bootstrap process and wait for the process to complete, set "waitForCompletion" to true.

The function will return one of the following:

The full API response for POST /internal/cluster/me/bootstrap?request_id={requestID} (waitForCompletion is set to true)

The full API response for POST /internal/cluster/me/bootstrap (waitForCompletion is set to false)

func (*Credentials) CloudObjectStore ¶

func (c *Credentials) CloudObjectStore(timeout ...int) (*CloudObjectStore, error)

CloudObjectStore retrieves all archive locations configured on the Rubik cluster.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	archiveLocations, err := rubrik.CloudObjectStore()
	if err != nil {
		log.Fatal(err)
	}

}

Output:

func (*Credentials) ClusterBootstrapStatus ¶

func (c *Credentials) ClusterBootstrapStatus(timeout ...int) (bool, error)

ClusterBootstrapStatus checks whether the cluster has been bootstrapped.

func (*Credentials) ClusterNodeIP ¶

func (c *Credentials) ClusterNodeIP(timeout ...int) ([]string, error)

ClusterNodeIP returns all Node IPs in the Rubrik cluster.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	clusterVersion, err := rubrik.ClusterNodeIP()
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) ClusterNodeName ¶

func (c *Credentials) ClusterNodeName(timeout ...int) ([]string, error)

ClusterNodeName returns the name of all nodes in the Rubrik cluster.

func (*Credentials) ClusterVersion ¶

func (c *Credentials) ClusterVersion(timeout ...int) (string, error)

ClusterVersion returns the CDM version of the Rubrik cluster.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	clusterVersion, err := rubrik.ClusterVersion()
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) ClusterVersionCheck ¶

func (c *Credentials) ClusterVersionCheck(clusterVersion float64, timeout ...int) error

ClusterVersionCheck is used to determine if the Rubrik cluster is using running an earlier release than the provided CDM "clusterVersion". If the CDM version is an earlier release than the "clusterVersion", the following message error message is thrown: Error: The Rubrik cluster must be running CDM version {clusterVersion} or later.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	clusterVersion := rubrik.ClusterVersionCheck(4.2)
	if clusterVersion != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) ConfigureDNSServers ¶

func (c *Credentials) ConfigureDNSServers(serverIP []string, timeout ...int) (*StatusCode, error)

ConfigureDNSServers provides the connection information for the DNS Servers used by the Rubrik cluster.

The function will return one of the following:

No change required. The Rubrik cluster is already configured with the provided DNS servers.

The full API response for POST /internal/cluster/me/dns_nameserver

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()

	dnsServers := []string{"192.168.100.5", "192.168.100.6"}

	dnsConfig, err := rubrik.ConfigureDNSServers(dnsServers)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) ConfigureNTP ¶

func (c *Credentials) ConfigureNTP(ntpServers []string, timeout ...int) (*StatusCode, error)

ConfigureNTP provides the connection information for the NTP servers used for time synchronization.

The function will return one of the following:

No change required. The NTP server(s) {ntpServers} has already been added to the Rubrik cluster.

The full API response for POST /internal/cluster/me/ntp_server

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	ntpServers := []string{"192.168.100.5", "192.168.100.6"}

	ntp, err := rubrik.ConfigureNTP(ntpServers)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) ConfigureSMTPSettings ¶

func (c *Credentials) ConfigureSMTPSettings(hostname, fromEmail, smtpUsername, smtpPassword, encryption string, port int, timeout ...int) (*SMTP, error)

ConfigureSMTPSettings provides the connection information to send notification email messages for delivery to the administrator accounts.

Valid encryption choices are:

NONE, SSL, and STARTTLS

The function will return one of the following:

No change required. The Rubrik cluster is already configured with the provided SMTP settings.

The full API response for POST /internal/smtp_instance

The full API response for PATCH /smtp_instance/{smtpID}

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	hostname := "smtp.rubrikgosdk.lab"
	port := 100
	fromEmail := "gosdk@rubrikgosdk.lab"
	username := "go"
	password := "sdk"
	encryption := "NONE"

	smtpConfig, err := rubrik.ConfigureSMTPSettings(hostname, fromEmail, username, password, encryption, port)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) ConfigureSearchDomain ¶

func (c *Credentials) ConfigureSearchDomain(searchDomain []string, timeout ...int) (*StatusCode, error)

ConfigureSearchDomain provides the connection information for the DNS search domains used by the Rubrik cluster.

The function will return one of the following:

No change required. The Rubrik cluster is already configured with the provided DNS search domains.

The full API response for POST /internal/cluster/me/dns_search_domain

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	searchDomains := []string{"rubrikgosdk.lab"}

	searchDomainConfig, err := rubrik.ConfigureSearchDomain(searchDomains)
	if err != nil {
		log.Fatal(err)
	}

}

Output:

func (*Credentials) ConfigureSyslog ¶

func (c *Credentials) ConfigureSyslog(syslogIP, protocol string, port float64, timeout ...int) (*Syslog, error)

ConfigureSyslog enables the Rubrik cluster to send syslog server messages that are based on the events that also appear in the Activity Log to the provided Syslog Server.

Valid protocol choices are:

UDP, TCP

The function will return one of the following:

No change required. The Rubrik cluster is already configured to use the syslog server '{syslogIP}' on port '{port}' using the '{protocol}' protocol.

The full API response for POST /internal/syslog

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	syslogIP := "192.168.100.7"
	syslogProtocol := "UDP"
	syslogPort := 514

	syslog, err := rubrik.ConfigureSyslog(syslogIP, syslogProtocol, syslogPort)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) ConfigureTimezone ¶

func (c *Credentials) ConfigureTimezone(timezone string, timeout ...int) (*ClusterProperties, error)

ConfigureTimezone provides the ability to set the time zone that is used by the Rubrik cluster which uses the specified time zone for time values in the web UI, all reports, SLA Domain settings, and all other time related operations.

Valid timezone choices are:

America/Anchorage, America/Araguaia, America/Barbados, America/Chicago, America/Denver, America/Los_Angeles America/Mexico_City, America/New_York,
America/Noronha, America/Phoenix, America/Toronto, America/Vancouver, Asia/Bangkok, Asia/Dhaka, Asia/Dubai, Asia/Hong_Kong, Asia/Karachi, Asia/Kathmandu,
Asia/Kolkata, Asia/Magadan, Asia/Singapore, Asia/Tokyo, Atlantic/Cape_Verde, Australia/Perth, Australia/Sydney, Europe/Amsterdam, Europe/Athens,
Europe/London, Europe/Moscow, Pacific/Auckland, Pacific/Honolulu, Pacific/Midway, or UTC.

The function will return one of the following:

No change required. The Rubrik cluster is already configured with '{timezone}' as it's timezone.

The full API response for POST /v1/cluster/me

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()

	confTimezone, err := rubrik.ConfigureTimezone("America/Los_Angeles")
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) ConfigureVLAN ¶

func (c *Credentials) ConfigureVLAN(netmask string, vlan int, ips map[string]string, timeout ...int) (*StatusCode, error)

ConfigureVLAN provides the VLAN VLAN tagging information which is an optional feature that allows a Rubrik cluster to efficiently switch network traffic using Virtual Local Area Networks. The ips map should be in a {nodeName:IP} format.

The function will return one of the following:

No change required. The Rubrik cluster is already configured with the provided VLAN information.

The full API response for POST /internal/cluster/me/vlan

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	vlanIPs := map[string]string{}
	vlanIPs["RVM157S018901"] = "192.168.100.100"
	vlanIPs["RVM157S018902"] = "192.168.100.101"
	vlanIPs["RVM157S018903"] = "192.168.100.102"
	vlanIPs["RVM157S0189014"] = "192.168.100.103"

	vlan := 100
	netmask := "255.255.255.0"

	configVLAN, err := rubrik.ConfigureVLAN(netmask, vlan, vlanIPs)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) DateTimeConversion ¶

func (c *Credentials) DateTimeConversion(dateTime string, timeout ...int) (string, error)

func (*Credentials) Delete ¶

func (c *Credentials) Delete(apiVersion, apiEndpoint string, timeout ...int) (interface{}, error)

Delete sends a DELETE request to the provided Rubrik API endpoint and returns the full API response. Supported "apiVersions" are v1, v2, and internal. The optional timeout value corresponds to the number of seconds to wait to establish a connection to the Rubrik cluster before returning a timeout error. If no value is provided, a default of 15 seconds will be used.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	deleteSLA, err := rubrik.Delete("v1", "/sla_domain/388a473c-3361-42ab-8f5b-08edb76891f6")
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) EndManagedVolumeSnapshot ¶

func (c *Credentials) EndManagedVolumeSnapshot(name, slaName string, timeout ...int) (*EndManagedVolumeSnapshot, error)

EndManagedVolumeSnapshot closes a managed volume for writes. A snapshot will be created containing all writes since the last begin snapshot call.

The function will return one of the following:

No change required. The Managed Volume '{name}' is already in a read-only state.

The full API response for POST /internal/managed_volume/{managedVolumeID}/end_snapshot

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	mvName := "GoSDK"
	slaName := "Gold"

	endMV, err := rubrik.EndManagedVolumeSnapshot(mvName, slaName)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) EndUserAuthorization ¶

func (c *Credentials) EndUserAuthorization(objectName, endUser, objectType string, timeout ...int) (*EndUserAuthorization, error)

EndUserAuthorization assigns an End User account privileges for a VMware virtual machine. VMware is currently the only supported "objectType"

The function will return one of the following:

No change required. The End User '{endUser}' is already authorized to interact with the '{objectName}' VM.

The full API response for POST /internal/authorization/role/end_user

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	vmName := "vm01"
	endUser := "user01"

	endUserAuth, err := rubrik.EndUserAuthorization(vmName, endUser, "VMware")
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) ExportEC2Instance ¶

func (c *Credentials) ExportEC2Instance(instanceID, exportedInstanceName, instanceType, awsRegion, subnetID, securityGroupID, dateTime string, waitForCompletion bool, timeout ...int) (interface{}, error)

ExportEC2Instance exports the latest snapshot of the specified EC2 instance.

The dateTime should be in the following format: "Month:Day:Year Hour:Minute AM/PM". Ex. 04-09-2019 05:56 PM. You may also use "latest" to export the last snapshot taken.

Valid "awsRegion" choices are:

ap-south-1,ap-northeast-3, ap-northeast-2, ap-southeast-1, ap-southeast-2, ap-northeast-1, ca-central-1, cn-north-1, cn-northwest-1, eu-central-1, eu-west-1,
eu-west-2, eu-west-3, us-west-1, us-east-1, us-east-2, and us-west-2.

Valid "instanceType" choices are:

a1.medium, a1.large, a1.xlarge, a1.2xlarge, a1.4xlarge, m4.large, m4.xlarge, m4.2xlarge, m4.4xlarge, m4.10xlarge, m4.16xlarge, m5.large, m5.xlarge, m5.2xlarge, m5.4xlarge, m5.12xlarge, m5.24xlarge, m5a.large, m5a.xlarge, m5a.2xlarge, m5a.4xlarge, m5a.12xlarge, m5a.24xlarge, m5d.large, m5d.xlarge, m5d.2xlarge, m5d.4xlarge, m5d.12xlarge, m5d.24xlarge, t2.nano, t2.micro, t2.small, t2.medium, t2.large, t2.xlarge, t2.2xlarge, t3.nano, t3.micro, t3.small, t3.medium, t3.large, t3.xlarge, t3.2xlarge, c4.large, c4.xlarge, c4.2xlarge, c4.4xlarge, c4.8xlarge, c5.large, c5.xlarge, c5.2xlarge, c5.4xlarge, c5.9xlarge, c5.18xlarge, c5d.xlarge, c5d.2xlarge, c5d.4xlarge, c5d.9xlarge, c5d.18xlarge, c5n.large, c5n.xlarge, c5n.2xlarge, c5n.4xlarge, c5n.9xlarge, c5n.18xlarge, r4.large, r4.xlarge, r4.2xlarge, r4.4xlarge, r4.8xlarge, r4.16xlarge, r5.large, r5.xlarge, r5.2xlarge, r5.4xlarge, r5.12xlarge, r5.24xlarge, r5a.large, r5a.xlarge, r5a.2xlarge, r5a.4xlarge, r5a.12xlarge, r5a.24xlarge, r5d.large, r5d.xlarge, r5d.2xlarge, r5d.4xlarge, r5d.12xlarge, r5d.24xlarge, x1.16xlarge, x1.32xlarge, x1e.xlarge, x1e.2xlarge, x1e.4xlarge, x1e.8xlarge, x1e.16xlarge, x1e.32xlarge, z1d.large, z1d.xlarge, z1d.2xlarge, z1d.3xlarge, z1d.6xlarge, z1d.12xlarge, d2.xlarge, d2.2xlarge, d2.4xlarge, d2.8xlarge, h1.2xlarge, h1.4xlarge, h1.8xlarge, h1.16xlarge, i3.large, i3.xlarge, i3.2xlarge, i3.4xlarge, i3.8xlarge, i3.16xlarge, f1.2xlarge, f1.4xlarge, f1.16xlarge, g3s.xlarge, g3.4xlarge, g3.8xlarge, g3.16xlarge, p2.xlarge, p2.8xlarge, p2.16xlarge, p3.2xlarge, p3.8xlarge, p3.16xlarge, and p3dn.24xlarge.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	instanceID := "i-0123456789abcdefg"
	exportInstanceName := "Go SDK"
	instanceType := "m4.large"
	awsRegion := "us-east-2"
	subnetID := "subnet-0123456789abcdefg"
	securityGroupID := "sg-0123456789abcdefg"
	dateTime := "04-09-2019 05:56 PM"
	waitForCompletion := true

	exportEC2, err := rubrik.ExportEC2Instance(instanceID, exportInstanceName, instanceType, awsRegion, subnetID, securityGroupID, dateTime, waitForCompletion)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) Get ¶

func (c *Credentials) Get(apiVersion, apiEndpoint string, timeout ...int) (interface{}, error)

Get sends a GET request to the provided Rubrik API endpoint and returns the full API response. Supported "apiVersions" are v1, v2, and internal. The optional timeout value corresponds to the number of seconds to wait to establish a connection to the Rubrik cluster before returning a timeout error. If no value is provided, a default of 15 seconds will be used.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	clusterInfo, err := rubrik.Get("v1", "/cluster/me")
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) GetSLAObjects ¶

func (c *Credentials) GetSLAObjects(slaName, objectType string, timeout ...int) (interface{}, error)

GetSLAObjects returns the name and ID of a specific object type.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	slaName := "Gold"

	getObjSLA, err := rubrik.GetSLAObjects(slaName, "VMware")
	if err != nil {
		log.Fatal(err)
	}

}

Output:

func (*Credentials) JobStatus ¶

func (c *Credentials) JobStatus(jobStatusURL string, timeout ...int) (interface{}, error)

JobStatus performs a GET operation to monitor the status of a specific Rubrik job want waits for it's completion.

func (*Credentials) ObjectID ¶

func (c *Credentials) ObjectID(objectName, objectType string, timeout int, hostOS ...string) (string, error)

ObjectID will search the Rubrik cluster for the provided "objectName" and return its ID/

Valid "objectType" choices are:

vmware, sla, vmwareHost, physicalHost, filesetTemplate, managedVolume, vcenter, and ec2.

When the "objectType" is "ec2", the objectName should correspond to the AWS Instance ID.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	slaName := "Gold"
	timeout := 15

	slaID, err := rubrik.ObjectID(slaName, "sla", timeout)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) OnDemandSnapshotPhysical ¶

func (c *Credentials) OnDemandSnapshotPhysical(hostName, slaName, fileset, hostOS string, timeout ...int) (string, error)

OnDemandSnapshotPhysical initiates an on-demand snapshot for a physical host ("hostname"). To use the currently assigned SLA Domain for the snapshot use "current" for the slaName.

Valid "hostOS" choices are:

Linux and Windows

The function will return:

The job status URL for the on-demand Snapshot

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	hostname := "vm01"
	slaName := "current"
	fileset := "C_Drive"
	hostOS := "Windows"

	hostSnapshot, err := rubrik.OnDemandSnapshotPhysical(hostname, slaName, fileset, hostOS)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) OnDemandSnapshotVM ¶

func (c *Credentials) OnDemandSnapshotVM(objectName, objectType, slaName string, timeout ...int) (string, error)

OnDemandSnapshotVM initiates an on-demand snapshot for the "objectName". The only "objectType" currently supported is vmware. To use the currently assigned SLA Domain for the snapshot use "current" for the slaName.

The function will return:

The job status URL for the on-demand Snapshot

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	vmName := "ansible-node01"
	sla := "current"

	vmSnapshot, err := rubrik.OnDemandSnapshotVM(vmName, "VMware", sla)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) Patch ¶

func (c *Credentials) Patch(apiVersion, apiEndpoint string, config interface{}, timeout ...int) (interface{}, error)

Patch sends a PATCH request to the provided Rubrik API endpoint and returns the full API response. Supported "apiVersions" are v1, v2, and internal. The optional timeout value corresponds to the number of seconds to wait to establish a connection to the Rubrik cluster before returning a timeout error. If no value is provided, a default of 15 seconds will be used.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	config := map[string]string{}
	config["configuredSlaDomainId"] = "388a473c-3361-42ab-8f5b-08edb76891f6"

	fileset, err := rubrik.Patch("v1", "/fileset/Fileset:::b95456e2-7d60-4ed0-af88-648516e139a6", config)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) PauseSnapshot ¶

func (c *Credentials) PauseSnapshot(objectName, objectType string, timeout ...int) (interface{}, error)

PauseSnapshot suspends all snapshot activity for the provided object. The only "objectType" current supported is vmware.

The function will return one of the following:

No change required. The '{objectName}' '{objectType}' is already paused.

The full API response for POST /internal/vmware/vm/{vmID}

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	vmName := "vm01"

	pauseVM, err := rubrik.PauseSnapshot(vmName, "VMware")
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) Post ¶

func (c *Credentials) Post(apiVersion, apiEndpoint string, config interface{}, timeout ...int) (interface{}, error)

Post sends a POST request to the provided Rubrik API endpoint and returns the full API response. Supported "apiVersions" are v1, v2, and internal. The optional timeout value corresponds to the number of seconds to wait to establish a connection to the Rubrik cluster before returning a timeout error. If no value is provided, a default of 15 seconds will be used.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	config := map[string]string{}
	config["slaId"] = "388a473c-3361-42ab-8f5b-08edb76891f6"

	onDemandSnapshot, err := rubrik.Post("v1", "/VMware/vm/VirtualMachine:::fbcb1f51-9520-4227-a68c-6fe145982f48-vm-204969/snapshot", config)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) RecoverFileDownload ¶

func (c *Credentials) RecoverFileDownload(hostName, fileset, hostOS, filePath, dateTime string, timeout ...int) (string, error)

RecoverFileDownload initiates to create a file download job from a fileset backup.

Valid "hostOS" choices are:

Linux and Windows

The function will return:

The job status URL for file download job from a fileset backup

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	hostName := "rubrik-sql01rubrikgosdk.lab"
	fileset := "fileset01"
	hostOS := "Linux"
	dateTime := "04-17-2020 12:49 PM"
	filePath := "/rubrik/bu-tar01/test01"

	fileDownload, err := rubrik.RecoverFileDownload(hostName, fileset, hostOS, filePath, dateTime)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) RefreshvCenter ¶

func (c *Credentials) RefreshvCenter(vCenterIP string, timeout ...int) (interface{}, error)

RefreshvCenter updates the the metadata for the specified vCenter Server and waits for the job to complete before returning the JobStatus API response.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	vcenter_hostname := "vcsa.rubrikgosdk.lab"

	refresh, err := rubrik.RefreshvCenter(vcenter_hostname)
	if err != nil {
		log.Fatal(err)

	}
}

Output:

func (*Credentials) RegisterCluster ¶

func (c *Credentials) RegisterCluster(username, password string, timeout ...int) (interface{}, error)

RegisterCluster submits the registration details for the specified Rubrik cluster. The username and password should correspond to your Rubrik Support Portal account. The default timeout value is 160 seconds.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	support_portal_username := "gosdk@rubrikgosdk.lab"
	support_portal_password := "GoDummyPassword"

	register, err := rubrik.RegisterCluster(support_portal_username, support_portal_password)
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) RemoveAWSAccount ¶

func (c *Credentials) RemoveAWSAccount(awsAccountName string, deleteExistingSnapshots bool, timeout ...int) (interface{}, error)

RemoveAWSAccount deletes the specific AWS account from the Rubrik cluster and waits for the job to complete before returning the JobStatus API response.

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	awsAccountName := "GO SDK Demo" // This is the name that will be displayed in the Rubrik UI
	deleteSnapshots := true

	removeAWSAccount, err := rubrik.RemoveAWSAccount(awsAccountName, deleteSnapshots)
	if err != nil {
		log.Fatal(err)
	}

}

Output:

func (*Credentials) RemoveArchiveLocation ¶

func (c *Credentials) RemoveArchiveLocation(archiveName string, timeout ...int) (*JobStatus, error)

RemoveArchiveLocation deletes the archival location from the SLA Domains that reference it and expire all snapshots at the archival location

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	archiveName := "Go SDK"

	removeArchive, err := rubrik.RemoveArchiveLocation(archiveName)
	if err != nil {
		log.Fatal(err)
	}

}

Output:

func (*Credentials) ResumeSnapshot ¶

func (c *Credentials) ResumeSnapshot(objectName, objectType string, timeout ...int) (interface{}, error)

ResumeSnapshot resumes all snapshot activity for the provided object. The only "objectType" currently supported is vmware.

The function will return one of the following:

No change required. The '{objectName}' '{objectType}' is currently not paused.

The full API response for POST /internal/vmware/vm/{vmID}

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	vmName := "vm01"

	resumeVM, err := rubrik.ResumeSnapshot(vmName, "VMware")
	if err != nil {
		log.Fatal(err)
	}
}

Output:

func (*Credentials) UpdateAWSNativeAccount ¶

func (c *Credentials) UpdateAWSNativeAccount(archiveName string, config map[string]interface{}, timeout ...int) (*UpdateAWSNative, error)

UpdateAWSNativeAccount updates the configuration of a AWS Native account. The following values, from PATCH /internal/aws/account/{id} are options for the config:

 {
  "name": "string",
  "accessKey": "string",
  "secretKey": "string",
  "regions": [
    "string"
  ],
  "regionalBoltNetworkConfigs": [
    {
      "region": "string",
      "vNetId": "string",
      "subnetId": "string",
      "securityGroupId": "string"
    }
  ],
  "disasterRecoveryArchivalLocationId": "string"
}

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	awsAccountName := "GO SDK Demo" // This is the name that will be displayed in the Rubrik UI
	newAWSAccountName := "GO SDK"

	config := make(map[string]interface{})
	config["name"] = newAWSAccountName

	updateAWSAccount, err := rubrik.UpdateAWSNativeAccount(awsAccountName, config)
	if err != nil {
		log.Fatal(err)
	}

}

Output:

func (*Credentials) UpdateCloudArchiveLocation ¶

func (c *Credentials) UpdateCloudArchiveLocation(archiveName string, config map[string]interface{}, timeout ...int) (*UpdateArchiveLocations, error)

UpdateCloudArchiveLocation updates the configuration of a the Cloud Archival Location. The following values, from PATCH /internal/object_store/{id} are options for the config:

{
   "name": "string",
   "accessKey": "string",
   "secretKey": "string",
   "endpoint": "string",
   "numBuckets": 0,
   "isComputeEnabled": true,
   "isConsolidationEnabled": true,
   "defaultComputeNetworkConfig": {
     "subnetId": "string",
     "vNetId": "string",
     "securityGroupId": "string",
     "resourceGroupId": "string"
   },
   "storageClass": "string",
   "glacierConfig": {
     "retrievalTier": "BulkRetrieval",
     "vaultLockPolicy": {
       "fileLockPeriodInDays": 0
     }
   },
   "azureComputeSummary": {
     "tenantId": "string",
     "subscriptionId": "string",
     "clientId": "string",
     "region": "string",
     "generalPurposeStorageAccountName": "string",
     "containerName": "string",
     "environment": "AZURE"
   },
   "azureComputeSecret": {
   "  clientSecret": "string"
   },
   "archivalProxyConfig": {
     "protocol": "HTTP",
     "proxyServer": "string",
     "portNumber": 0,
     "userName": "string",
     "password": "string"
   },
   "computeProxyConfig": {
     "protocol": "HTTP",
     "proxyServer": "string",
     "portNumber": 0,
     "userName": "string",
     "password": "string"
   }
 }

package main

import (
	"log"

	"github.com/rubrikinc/rubrik-sdk-for-go/rubrikcdm"
)

func main() {
	rubrik, err := rubrikcdm.ConnectEnv()
	if err != nil {
		log.Fatal(err)
	}

	archiveName := "Go SDK"
	storageClass := "standard"

	config := make(map[string]interface{})
	config["storageClass"] = storageClass

	updateArchive, err := rubrik.UpdateCloudArchiveLocation(archiveName, config)
	if err != nil {
		log.Fatal(err)
	}

}

Output: