import "github.com/oracle/oci-go-sdk/example"▹ Example (ChangeCompartment)
▾ Example (ChangeCompartment)
Code:
package example
import (
"context"
"fmt"
"log"
"math"
"os"
"time"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/core"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
"github.com/oracle/oci-go-sdk/v65/workrequests"
)
var (
instanceId, targetCompartmentId, ifMatch, opcRetryToken string
retryPolicy common.RetryPolicy
)
func Example_changeCompartment() {
// Parse environment variables to get instanceId, targetCompartmentId, ifMatch and opcRetryToken
parseEnvironmentVariables()
// Create ComputeClient with default configuration
computeClient, err := core.NewComputeClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
ctx := context.Background()
// Get Compartment Id of the Instance
request := core.GetInstanceRequest{
InstanceId: common.String(instanceId),
}
r, err := computeClient.GetInstance(ctx, request)
helpers.FatalIfError(err)
availabilityDomain := *r.AvailabilityDomain
sourceCompartmentID := *r.Instance.CompartmentId
// Do not attempt compartment move, if the source and target compartment ids are same
if sourceCompartmentID == targetCompartmentId {
log.Printf("Source and target compartment ids are same !")
os.Exit(1)
}
log.Printf(" ")
log.Printf("Instance info before compartment move : ")
if r.Etag != nil {
log.Printf(" ETag : %s", *r.Etag)
}
printInstanceInfo(sourceCompartmentID, computeClient, availabilityDomain)
// Create ChangeInstanceCompartmentDetails
changeInstanceCompartmentDetails := core.ChangeInstanceCompartmentDetails{
CompartmentId: common.String(targetCompartmentId),
}
// Create ChangeInstanceCompartmentRequest
changeInstanceCompartmentRequest := core.ChangeInstanceCompartmentRequest{
InstanceId: common.String(instanceId),
ChangeInstanceCompartmentDetails: changeInstanceCompartmentDetails,
}
if len(ifMatch) > 0 {
changeInstanceCompartmentRequest.IfMatch = common.String(ifMatch)
}
if len(opcRetryToken) > 0 {
changeInstanceCompartmentRequest.OpcRetryToken = common.String(opcRetryToken)
}
log.Printf(" ")
log.Printf("Moving Instance to target compartment ...")
// Perform compartment move operation
rs, err := computeClient.ChangeInstanceCompartment(ctx, changeInstanceCompartmentRequest)
helpers.FatalIfError(err)
//Wait for compartment move operation
waitUnitlMoveCompletion(rs.OpcWorkRequestId)
log.Printf(" ")
log.Printf("Instance info after compartment move : ")
printInstanceInfo(targetCompartmentId, computeClient, availabilityDomain)
log.Printf(" ")
fmt.Println("Change Compartment Completed")
// Output:
// Change Compartment Completed
}
func printInstanceInfo(id string, c core.ComputeClient, availabilityDomain string) {
log.Printf(" Compartment Id : %s", id)
printVolumeAttachments(c, id)
printVnicAttachments(c, id)
printBootVolumecAttachments(c, availabilityDomain, id)
printConsoleConnections(c, id)
printConsoleHistories(c, id)
}
func printVolumeAttachments(c core.ComputeClient, compartmentId string) {
request := core.ListVolumeAttachmentsRequest{
CompartmentId: common.String(compartmentId),
InstanceId: common.String(instanceId),
}
lvar, err := c.ListVolumeAttachments(context.Background(), request)
helpers.FatalIfError(err)
var volumeAttachments = lvar.Items
if len(volumeAttachments) > 0 {
log.Printf(" Volume Attachments:")
for _, v := range volumeAttachments {
log.Printf(" Volume id : %s", *v.GetId())
log.Printf(" Compartment id : %s", *v.GetCompartmentId())
log.Printf(" State : %s", v.GetLifecycleState())
log.Printf(" ")
}
}
}
func printVnicAttachments(c core.ComputeClient, compartmentId string) {
request := core.ListVnicAttachmentsRequest{
CompartmentId: common.String(compartmentId),
InstanceId: common.String(instanceId),
}
lvar, err := c.ListVnicAttachments(context.Background(), request)
helpers.FatalIfError(err)
var vnicAttachments = lvar.Items
if len(vnicAttachments) > 0 {
log.Printf(" Vnic Attachments:")
for _, v := range vnicAttachments {
log.Printf(" Vnic id : %s", *v.VnicId)
log.Printf(" Compartment id : %s", *v.CompartmentId)
log.Printf(" State : %s", v.LifecycleState)
log.Printf(" ")
}
}
}
func printBootVolumecAttachments(c core.ComputeClient, availabilityDomain string, compartmentId string) {
request := core.ListBootVolumeAttachmentsRequest{
CompartmentId: common.String(compartmentId),
InstanceId: common.String(instanceId),
AvailabilityDomain: common.String(availabilityDomain),
}
lvar, err := c.ListBootVolumeAttachments(context.Background(), request)
helpers.FatalIfError(err)
var bootVolumeAttachments = lvar.Items
if len(bootVolumeAttachments) > 0 {
log.Printf(" Boot Volume Attachments:")
for _, v := range bootVolumeAttachments {
log.Printf(" Volume id : %s", *v.BootVolumeId)
log.Printf(" Compartment id : %s", *v.CompartmentId)
log.Printf(" State : %s", v.LifecycleState)
log.Printf(" ")
}
}
}
func printConsoleConnections(c core.ComputeClient, compartmentId string) {
request := core.ListInstanceConsoleConnectionsRequest{
CompartmentId: common.String(compartmentId),
InstanceId: common.String(instanceId),
}
lvar, err := c.ListInstanceConsoleConnections(context.Background(), request)
helpers.FatalIfError(err)
var consoleConnections = lvar.Items
if len(consoleConnections) > 0 {
log.Printf(" Console Connections:")
for _, v := range consoleConnections {
log.Printf(" Console Connection Id : %s", *v.Id)
log.Printf(" Compartment Id : %s", *v.CompartmentId)
log.Printf(" State : %s", v.LifecycleState)
log.Printf(" ")
}
}
}
func printConsoleHistories(c core.ComputeClient, compartmentId string) {
request := core.ListConsoleHistoriesRequest{
CompartmentId: common.String(compartmentId),
InstanceId: common.String(instanceId),
}
lvar, err := c.ListConsoleHistories(context.Background(), request)
helpers.FatalIfError(err)
var consoleHistories = lvar.Items
if len(consoleHistories) > 0 {
log.Printf(" Console Histories:")
for _, v := range consoleHistories {
log.Printf(" Console Connection Id : %s", *v.Id)
log.Printf(" Compartment Id : %s", *v.CompartmentId)
log.Printf(" State : %s", v.LifecycleState)
log.Printf(" ")
}
}
}
func waitUnitlMoveCompletion(opcWorkRequestID *string) {
if opcWorkRequestID != nil {
log.Printf(" opc-work-request-id : %s", *opcWorkRequestID)
log.Printf(" Querying the status of move operation using opc-work-request-id ")
wc, _ := workrequests.NewWorkRequestClientWithConfigurationProvider(common.DefaultConfigProvider())
retryPolicy = getRetryPolicy()
// Apply wait until work complete retryPolicy
workRequest := workrequests.GetWorkRequestRequest{
WorkRequestId: opcWorkRequestID,
RequestMetadata: common.RequestMetadata{
RetryPolicy: &retryPolicy,
},
}
// GetWorkRequest get retried until the work request is in Succeeded status
wr, err := wc.GetWorkRequest(context.Background(), workRequest)
helpers.FatalIfError(err)
if wr.Status != "" {
log.Printf(" Final Work Status : %s, move operation complete", wr.Status)
}
}
}
func getRetryPolicy() common.RetryPolicy {
// maximum times of retry
attempts := uint(10)
nextDuration := func(r common.OCIOperationResponse) time.Duration {
// you might want wait longer for next retry when your previous one failed
// this function will return the duration as:
// 1s, 2s, 4s, 8s, 16s, 32s, 64s etc...
return time.Duration(math.Pow(float64(2), float64(r.AttemptNumber-1))) * time.Second
}
var expectedWorkStatus = workrequests.WorkRequestStatusSucceeded
// Get shouldRetry function based on GetWorkRequestResponse Status
shouldRetry := func(r common.OCIOperationResponse) bool {
if _, isServiceError := common.IsServiceError(r.Error); isServiceError {
// not service error, could be network error or other errors which prevents
// request send to server, will do retry here
return true
}
if converted, ok := r.Response.(workrequests.GetWorkRequestResponse); ok {
log.Printf(" WorkRequest Status : %s", converted.Status)
// do the retry until WorkReqeut Status is Succeeded - ignore case (BMI-2652)
return converted.Status != expectedWorkStatus
}
return true
}
return common.NewRetryPolicy(attempts, shouldRetry, nextDuration)
}
func usage() {
log.Printf("Please set the following environment variables to use ChangeInstanceCompartment()")
log.Printf(" ")
log.Printf(" INSTANCE_ID # Required: Instance Id")
log.Printf(" COMPARTMENT_ID # Required: Target Compartment Id")
log.Printf(" IF_MATCH # Optional: ETag")
log.Printf(" OPC_RETRY_TOKEN # Optional: OPC retry token string")
log.Printf(" ")
os.Exit(1)
}
func parseEnvironmentVariables() {
instanceId = os.Getenv("INSTANCE_ID")
targetCompartmentId = os.Getenv("COMPARTMENT_ID")
ifMatch = os.Getenv("IF_MATCH")
opcRetryToken = os.Getenv("OPC_RETRY_TOKEN")
if instanceId == "" || targetCompartmentId == "" {
usage()
}
log.Printf("INSTANCE_ID : %s", instanceId)
log.Printf("COMPARTMENT_ID : %s", targetCompartmentId)
if ifMatch != "" {
log.Printf("IF_MATCH : %s", ifMatch)
}
if opcRetryToken != "" {
log.Printf("OPC_RETRY_TOKEN : %s", opcRetryToken)
}
}
▹ Example (ChangeNatGatewayCompartment)
▾ Example (ChangeNatGatewayCompartment)
Code:
package example
import (
"context"
"fmt"
"log"
"os"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/core"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
)
const (
displayName = "oci-go-sdk-example-ngw"
)
var (
sourceCompartmentId, destinationCompartmentId string
)
func Example_changeNatGatewayCompartment() {
// Parse environment variables to get sourceCompartmentId and destinationCompartmentId
parseArgs()
log.Printf("Performing operations to change NAT Gateway compartment from %s to %s", sourceCompartmentId, destinationCompartmentId)
// Create VirtualNetworkClient with default configuration
vcnClient, err := core.NewVirtualNetworkClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
ctx := context.Background()
// A VCN is required to create a NAT Gateway
vcn := createVcnforNatGateway(ctx, vcnClient)
log.Printf("Created VCN: %s", *vcn.Id)
log.Printf("")
// Create NAT Gateway
natGateway := createNatGateway(ctx, vcnClient, vcn)
// Change NAT Gateway's compartment
changeNatGatewayCompartment(ctx, vcnClient, natGateway)
fmt.Printf("Change NAT Gateway Compartment Completed")
// Clean up resources
defer func() {
deleteNatGateway(ctx, vcnClient, natGateway)
log.Printf("Deleted NAT Gateway")
deleteVcnforNatGateway(ctx, vcnClient, vcn)
log.Printf("Deleted VCN")
}()
// Output:
// Change NAT Gateway Compartment Completed
}
func createVcnforNatGateway(ctx context.Context, c core.VirtualNetworkClient) core.Vcn {
// create a new VCN
request := core.CreateVcnRequest{}
request.CidrBlock = common.String("10.0.0.0/16")
request.CompartmentId = common.String(sourceCompartmentId)
request.DisplayName = common.String(displayName)
r, err := c.CreateVcn(ctx, request)
helpers.FatalIfError(err)
// below logic is to wait until VCN is in Available state
pollUntilAvailable := func(r common.OCIOperationResponse) bool {
if converted, ok := r.Response.(core.GetVcnResponse); ok {
return converted.LifecycleState != core.VcnLifecycleStateAvailable
}
return true
}
pollGetRequest := core.GetVcnRequest{
VcnId: r.Id,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(pollUntilAvailable),
}
// wait for VCN to become Available
rsp, pollErr := c.GetVcn(ctx, pollGetRequest)
helpers.FatalIfError(pollErr)
return rsp.Vcn
}
func deleteVcnforNatGateway(ctx context.Context, c core.VirtualNetworkClient, vcn core.Vcn) {
request := core.DeleteVcnRequest{
VcnId: vcn.Id,
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
_, err := c.DeleteVcn(ctx, request)
helpers.FatalIfError(err)
// should retry condition check which returns a bool value indicating whether to do retry or not
// it checks if the lifecycle state equals Terminated
shouldRetryFunc := func(r common.OCIOperationResponse) bool {
if serviceError, ok := common.IsServiceError(r.Error); ok && serviceError.GetHTTPStatusCode() == 404 {
// resource been deleted, stop retry
return false
}
if converted, ok := r.Response.(core.GetVcnResponse); ok {
return converted.LifecycleState != core.VcnLifecycleStateTerminated
}
return true
}
pollGetRequest := core.GetVcnRequest{
VcnId: vcn.Id,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryFunc),
}
_, pollErr := c.GetVcn(ctx, pollGetRequest)
if serviceError, ok := common.IsServiceError(pollErr); !ok ||
(ok && serviceError.GetHTTPStatusCode() != 404) {
// fail if the error is not service error or
// if the error is service error and status code not equals to 404
helpers.FatalIfError(pollErr)
}
}
func createNatGateway(ctx context.Context, c core.VirtualNetworkClient, vcn core.Vcn) core.NatGateway {
log.Printf("Creating NAT Gateway")
log.Printf("=======================================")
createNatGatewayDetails := core.CreateNatGatewayDetails{
CompartmentId: common.String(sourceCompartmentId),
VcnId: vcn.Id,
DisplayName: common.String(displayName),
}
request := core.CreateNatGatewayRequest{}
request.CreateNatGatewayDetails = createNatGatewayDetails
r, err := c.CreateNatGateway(ctx, request)
helpers.FatalIfError(err)
// below logic is to wait until NAT Gateway is in Available state
pollUntilAvailable := func(r common.OCIOperationResponse) bool {
if converted, ok := r.Response.(core.GetNatGatewayResponse); ok {
return converted.LifecycleState != core.NatGatewayLifecycleStateAvailable
}
return true
}
pollGetRequest := core.GetNatGatewayRequest{
NatGatewayId: r.Id,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(pollUntilAvailable),
}
// wait for lifecyle become Available
rsp, pollErr := c.GetNatGateway(ctx, pollGetRequest)
helpers.FatalIfError(pollErr)
log.Printf("Created NAT Gateway and waited for it to become available %v\n", rsp.NatGateway)
log.Printf("")
log.Printf("")
return rsp.NatGateway
}
func getNatGateway(ctx context.Context, c core.VirtualNetworkClient, natGateway core.NatGateway) core.NatGateway {
request := core.GetNatGatewayRequest{
NatGatewayId: natGateway.Id,
}
r, err := c.GetNatGateway(ctx, request)
helpers.FatalIfError(err)
return r.NatGateway
}
func deleteNatGateway(ctx context.Context, c core.VirtualNetworkClient, natGateway core.NatGateway) {
request := core.DeleteNatGatewayRequest{
NatGatewayId: natGateway.Id,
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
_, err := c.DeleteNatGateway(ctx, request)
helpers.FatalIfError(err)
// should retry condition check which returns a bool value indicating whether to do retry or not
// it checks the lifecycle status equals to Terminated or not for this case
shouldRetryFunc := func(r common.OCIOperationResponse) bool {
if serviceError, ok := common.IsServiceError(r.Error); ok && serviceError.GetHTTPStatusCode() == 404 {
// resource been deleted, stop retry
return false
}
if converted, ok := r.Response.(core.GetNatGatewayResponse); ok {
return converted.LifecycleState != core.NatGatewayLifecycleStateTerminated
}
return true
}
pollGetRequest := core.GetNatGatewayRequest{
NatGatewayId: natGateway.Id,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryFunc),
}
_, pollErr := c.GetNatGateway(ctx, pollGetRequest)
if serviceError, ok := common.IsServiceError(pollErr); !ok ||
(ok && serviceError.GetHTTPStatusCode() != 404) {
// fail if the error is not service error or
// if the error is service error and status code not equals to 404
helpers.FatalIfError(pollErr)
}
}
func changeNatGatewayCompartment(ctx context.Context, c core.VirtualNetworkClient, natGateway core.NatGateway) {
log.Printf("Changing NAT Gateway's compartment")
log.Printf("=======================================")
changeNatGatewayCompartmentDetails := core.ChangeNatGatewayCompartmentDetails{
CompartmentId: common.String(destinationCompartmentId),
}
request := core.ChangeNatGatewayCompartmentRequest{}
request.NatGatewayId = natGateway.Id
request.ChangeNatGatewayCompartmentDetails = changeNatGatewayCompartmentDetails
_, err := c.ChangeNatGatewayCompartment(ctx, request)
helpers.FatalIfError(err)
updatedNatGateway := getNatGateway(ctx, c, natGateway)
log.Printf("NAT Gateway's compartment has been changed : %v\n", updatedNatGateway)
log.Printf("")
log.Printf("")
}
func envUsage() {
log.Printf("Please set the following environment variables to use ChangeInstanceCompartment()")
log.Printf(" ")
log.Printf(" SOURCE_COMPARTMENT_ID # Required: Source Compartment Id")
log.Printf(" DESTINATION_COMPARTMENT_ID # Required: Destination Compartment Id")
log.Printf(" ")
os.Exit(1)
}
func parseArgs() {
sourceCompartmentId = os.Getenv("SOURCE_COMPARTMENT_ID")
destinationCompartmentId = os.Getenv("DESTINATION_COMPARTMENT_ID")
if sourceCompartmentId == "" || destinationCompartmentId == "" {
envUsage()
}
log.Printf("SOURCE_COMPARTMENT_ID : %s", sourceCompartmentId)
log.Printf("DESTINATION_COMPARTMENT_ID : %s", destinationCompartmentId)
}
▹ Example (ChangeServiceGatewayCompartment)
▾ Example (ChangeServiceGatewayCompartment)
Code:
package example
import (
"context"
"fmt"
"log"
"os"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/core"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
)
const (
serviceGatewayVcnDisplayName = "OCI-GOSDK-Sample"
)
var (
srcCompartmentId, destCompartmentId string
)
func Example_changeServiceGatewayCompartment() {
// Parse environment variables to get srcCompartmentId, destCompartmentId
parseEnvVariables()
// Create VirtualNetworkClient with default configuration
client, err := core.NewVirtualNetworkClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
ctx := context.Background()
log.Printf("Create Vcn ")
vcn := createSgwVcn(ctx, client)
log.Printf("VCN OCID : %s", *vcn.Id)
log.Printf("Create Service Gateway")
sgw := createServiceGateway(ctx, client, vcn)
log.Printf("Service Gateway OCID : %s", *sgw.Id)
log.Printf("Change Service Gateway Compartment")
changeServiceGatewayCompartment(ctx, client, sgw)
updatedsgw := getServiceGateway(ctx, client, sgw)
log.Printf("Updated Service Gateway Compartment : %s", *updatedsgw.CompartmentId)
fmt.Printf("change compartment completed")
// clean up resources
defer func() {
log.Printf("Delete Service Gateway")
deleteServiceGateway(ctx, client, sgw)
log.Printf("Deleted Service Gateway")
log.Printf("Delete VCN")
deleteSgwVcn(ctx, client, vcn)
log.Printf("Deleted VCN")
}()
// Output:
// change compartment completed
}
func createSgwVcn(ctx context.Context, c core.VirtualNetworkClient) core.Vcn {
// create a new VCN
request := core.CreateVcnRequest{}
request.CidrBlock = common.String("10.0.0.0/16")
request.CompartmentId = common.String(srcCompartmentId)
request.DisplayName = common.String(serviceGatewayVcnDisplayName)
r, err := c.CreateVcn(ctx, request)
helpers.FatalIfError(err)
// below logic is to wait until VCN is in Available state
pollUntilAvailable := func(r common.OCIOperationResponse) bool {
if converted, ok := r.Response.(core.GetVcnResponse); ok {
return converted.LifecycleState != core.VcnLifecycleStateAvailable
}
return true
}
pollGetRequest := core.GetVcnRequest{
VcnId: r.Id,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(pollUntilAvailable),
}
// wait for lifecyle become Available
rsp, pollErr := c.GetVcn(ctx, pollGetRequest)
helpers.FatalIfError(pollErr)
return rsp.Vcn
}
func deleteSgwVcn(ctx context.Context, c core.VirtualNetworkClient, vcn core.Vcn) {
request := core.DeleteVcnRequest{
VcnId: vcn.Id,
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
_, err := c.DeleteVcn(ctx, request)
helpers.FatalIfError(err)
// should retry condition check which returns a bool value indicating whether to do retry or not
// it checks the lifecycle status equals to Terminated or not for this case
shouldRetryFunc := func(r common.OCIOperationResponse) bool {
if serviceError, ok := common.IsServiceError(r.Error); ok && serviceError.GetHTTPStatusCode() == 404 {
// resource been deleted, stop retry
return false
}
if converted, ok := r.Response.(core.GetVcnResponse); ok {
return converted.LifecycleState != core.VcnLifecycleStateTerminated
}
return true
}
pollGetRequest := core.GetVcnRequest{
VcnId: vcn.Id,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryFunc),
}
_, pollErr := c.GetVcn(ctx, pollGetRequest)
if serviceError, ok := common.IsServiceError(pollErr); !ok ||
(ok && serviceError.GetHTTPStatusCode() != 404) {
// fail if the error is not service error or
// if the error is service error and status code not equals to 404
helpers.FatalIfError(pollErr)
}
}
func createServiceGateway(ctx context.Context, c core.VirtualNetworkClient, vcn core.Vcn) core.ServiceGateway {
// Update the services field to required Oracle Services
var services = []core.ServiceIdRequestDetails{}
createServiceGatewayDetails := core.CreateServiceGatewayDetails{
CompartmentId: common.String(srcCompartmentId),
VcnId: vcn.Id,
DisplayName: common.String(serviceGatewayVcnDisplayName),
Services: services,
}
// create a new VCN
request := core.CreateServiceGatewayRequest{}
request.CreateServiceGatewayDetails = createServiceGatewayDetails
r, err := c.CreateServiceGateway(ctx, request)
helpers.FatalIfError(err)
// below logic is to wait until VCN is in Available state
pollUntilAvailable := func(r common.OCIOperationResponse) bool {
if converted, ok := r.Response.(core.GetServiceGatewayResponse); ok {
return converted.LifecycleState != core.ServiceGatewayLifecycleStateAvailable
}
return true
}
pollGetRequest := core.GetServiceGatewayRequest{
ServiceGatewayId: r.Id,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(pollUntilAvailable),
}
// wait for lifecyle become Available
rsp, pollErr := c.GetServiceGateway(ctx, pollGetRequest)
helpers.FatalIfError(pollErr)
return rsp.ServiceGateway
}
func deleteServiceGateway(ctx context.Context, c core.VirtualNetworkClient, serviceGateway core.ServiceGateway) {
request := core.DeleteServiceGatewayRequest{
ServiceGatewayId: serviceGateway.Id,
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
_, err := c.DeleteServiceGateway(ctx, request)
helpers.FatalIfError(err)
// should retry condition check which returns a bool value indicating whether to do retry or not
// it checks the lifecycle status equals to Terminated or not for this case
shouldRetryFunc := func(r common.OCIOperationResponse) bool {
if serviceError, ok := common.IsServiceError(r.Error); ok && serviceError.GetHTTPStatusCode() == 404 {
// resource been deleted, stop retry
return false
}
if converted, ok := r.Response.(core.GetServiceGatewayResponse); ok {
return converted.LifecycleState != core.ServiceGatewayLifecycleStateTerminated
}
return true
}
pollGetRequest := core.GetServiceGatewayRequest{
ServiceGatewayId: serviceGateway.Id,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryFunc),
}
_, pollErr := c.GetServiceGateway(ctx, pollGetRequest)
if serviceError, ok := common.IsServiceError(pollErr); !ok ||
(ok && serviceError.GetHTTPStatusCode() != 404) {
// fail if the error is not service error or
// if the error is service error and status code not equals to 404
helpers.FatalIfError(pollErr)
}
}
func changeServiceGatewayCompartment(ctx context.Context, c core.VirtualNetworkClient, serviceGateway core.ServiceGateway) {
changeCompartmentDetails := core.ChangeServiceGatewayCompartmentDetails{
CompartmentId: common.String(destCompartmentId),
}
request := core.ChangeServiceGatewayCompartmentRequest{}
request.ServiceGatewayId = serviceGateway.Id
request.ChangeServiceGatewayCompartmentDetails = changeCompartmentDetails
_, err := c.ChangeServiceGatewayCompartment(ctx, request)
helpers.FatalIfError(err)
}
func getServiceGateway(ctx context.Context, c core.VirtualNetworkClient, serviceGateway core.ServiceGateway) core.ServiceGateway {
request := core.GetServiceGatewayRequest{
ServiceGatewayId: serviceGateway.Id,
}
r, err := c.GetServiceGateway(ctx, request)
helpers.FatalIfError(err)
return r.ServiceGateway
}
func printUsage() {
fmt.Printf("Please set the following environment variables to use ChangeServiceGatewayCompartment()")
fmt.Printf(" ")
fmt.Printf(" SRC_COMPARTMENT_ID # Required: Source Compartment Id")
fmt.Printf(" DEST_COMPARTMENT_ID # Required: Destination Compartment Id")
fmt.Printf(" ")
os.Exit(1)
}
func parseEnvVariables() {
srcCompartmentId = os.Getenv("SRC_COMPARTMENT_ID")
destCompartmentId = os.Getenv("DEST_COMPARTMENT_ID")
if srcCompartmentId == "" || destCompartmentId == "" {
printUsage()
}
log.Printf("SRC_COMPARTMENT_ID : %s", srcCompartmentId)
log.Printf("DEST_COMPARTMENT_ID : %s", destCompartmentId)
}
▹ Example (ClusterCRUD)
▾ Example (ClusterCRUD)
Example for how to do CRUD on cluster, how to get kubernets config and how to work with WorkRequest
Code:
ctx := context.Background() c, clerr := containerengine.NewContainerEngineClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(clerr) // create network resources for cluster. // this sample is to demonstrate how to use cluster APIs // for more configuration setup, please refer to the link here: // https://docs.oracle.com/iaas/Content/ContEng/Concepts/contengnetworkconfig.htm vcnID, subnet1ID, _ := createVCNWithSubnets(ctx) defaulKubetVersion := getDefaultKubernetesVersion(c) createClusterResp := createCluster(ctx, c, vcnID, defaulKubetVersion, subnet1ID) // wait until work request complete workReqResp := waitUntilWorkRequestComplete(c, createClusterResp.OpcWorkRequestId) fmt.Println("cluster created") // update cluster with a new name and upgrade the kubernets version updateReq := containerengine.UpdateClusterRequest{} // please see the document here for actionType values: // https://docs.oracle.com/iaas/api/#/en/containerengine/20180222/datatypes/WorkRequestResource clusterID := getResourceID(workReqResp.Resources, containerengine.WorkRequestResourceActionTypeCreated, "CLUSTER") updateReq.ClusterId = clusterID defer deleteCluster(ctx, c, clusterID) updateReq.Name = common.String("GOSDK_Sample_New_CE") getReq := containerengine.GetClusterRequest{ ClusterId: updateReq.ClusterId, } getResp, err := c.GetCluster(ctx, getReq) // check for upgrade versions if len(getResp.Cluster.AvailableKubernetesUpgrades) > 0 { // if newer version available, set it for upgrade updateReq.KubernetesVersion = common.String(getResp.Cluster.AvailableKubernetesUpgrades[0]) } updateResp, err := c.UpdateCluster(ctx, updateReq) helpers.FatalIfError(err) fmt.Println("updating cluster") // wait until update complete workReqResp = waitUntilWorkRequestComplete(c, updateResp.OpcWorkRequestId) fmt.Println("cluster updated") // get cluster getResp, err = c.GetCluster(ctx, getReq) helpers.FatalIfError(err) fmt.Printf("cluster name updated to %s\n", *getResp.Name)
Output:
create VCN complete create subnet1 complete create subnet2 complete creating cluster cluster created updating cluster cluster updated cluster name updated to GOSDK_Sample_New_CE deleting cluster
▹ Example (ConfigureCircuitBreaker)
▾ Example (ConfigureCircuitBreaker)
Example shows how to configure circuit breaker
Code:
// If need to disable all service default circuit breaker, there are two ways: set circuit breaker environment variable to false // or use global variable. // common.GlobalCircuitBreakerSetting = common.NoCircuitBreaker() identityClient, err := identity.NewIdentityClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(err) // Add one more status code 404(compare with default circuit breaker setting) as the failure request in circuit breaker. successStatCodeMap := map[int]bool{ 429: false, 404: false, 500: false, 502: false, 503: false, 504: false, } // Configure CircuitBreaker cbst := common.NewCircuitBreakerSettingWithOptions( common.WithName("myCircuitBreaker"), common.WithIsEnabled(true), common.WithMinimumRequests(5), common.WithCloseStateWindow(60*time.Second), common.WithFailureRateThreshold(0.70), common.WithSuccessStatCodeMap(successStatCodeMap), common.WithServiceName("Identity")) // if prefer to use default circuit breaker, no need to define successStatCodeMap and cb, but directly call: // cbst := common.DefaultCircuitBreakerSetting() identityClient.BaseClient.Configuration.CircuitBreaker = common.NewCircuitBreaker(cbst) // The OCID of the tenancy containing the compartment. tenancyID, err := common.DefaultConfigProvider().TenancyOCID() helpers.FatalIfError(err) // make the tenancyOCID incorrect on purpose - testing fakeTenancyID := tenancyID[1:len(tenancyID)-2] + "mm" request := identity.ListAvailabilityDomainsRequest{ CompartmentId: &fakeTenancyID, } for i := 0; i < 5; i++ { identityClient.ListAvailabilityDomains(context.Background(), request) fmt.Println(i*10, "seconds CircuitBreaker state: "+identityClient.Configuration.CircuitBreaker.Cb.State().String()) time.Sleep(10 * time.Second) } time.Sleep(5 * time.Second) fmt.Println("After 55s, CircuitBreaker current state: " + identityClient.Configuration.CircuitBreaker.Cb.State().String()) fmt.Println("Wait 30 sec...") time.Sleep(30 * time.Second) fmt.Println("Make a good API call") request = identity.ListAvailabilityDomainsRequest{ CompartmentId: &tenancyID, } identityClient.ListAvailabilityDomains(context.Background(), request) time.Sleep(10 * time.Second) fmt.Println("check current CircuitBreaker state: " + identityClient.Configuration.CircuitBreaker.Cb.State().String())
Output:
0 seconds CircuitBreaker state: closed 10 seconds CircuitBreaker state: closed 20 seconds CircuitBreaker state: closed 30 seconds CircuitBreaker state: closed 40 seconds CircuitBreaker state: open After 55s, CircuitBreaker current state: open Wait 30 sec... Make a good API call check current CircuitBreaker state: closed
▹ Example (CopyVolumeBackup)
▾ Example (CopyVolumeBackup)
Copies a volume backup to another region. Polls the copied volume backup in the destination region until it's lifecycle is Available.
Code:
sourceBackupId := "REPLACE_WITH_VOLUME_BACKUP_OCID" destinationRegion := "REPLACE_WITH_DESTINATION_REGION_NAME" // displayName can be empty, in which case the copied backup will have the same display name as the original backup displayName := "" // kmsKey is optional too. If not specified, the copied backup is going to be encrypted with oracle provided // encryption keys. kmsKeyId := "" //Creating the copyVolumeBackupRequest request := core.CopyVolumeBackupRequest{ CopyVolumeBackupDetails: core.CopyVolumeBackupDetails{ DestinationRegion: common.String(destinationRegion), }, VolumeBackupId: common.String(sourceBackupId), } if len(displayName) > 0 { request.CopyVolumeBackupDetails.DisplayName = common.String(displayName) } if len(kmsKeyId) > 0 { request.CopyVolumeBackupDetails.KmsKeyId = common.String(kmsKeyId) } // Creating a Blockstorage client in the source region to initiate the copy. bs, err := core.NewBlockstorageClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(err) fmt.Println("Copying backup.") copyResponse, err := bs.CopyVolumeBackup(context.Background(), request) volumeBackup := copyResponse.VolumeBackup helpers.FatalIfError(err) fmt.Println("Copy backup request accepted waiting for the backup to be in Available state.") backupState := volumeBackup.LifecycleState // Creating a Blockstorage client in the destination region and // poll on the copied volume backup's lifecycle state. destinationBS, err := core.NewBlockstorageClientWithConfigurationProvider(common.DefaultConfigProvider()) destinationBS.SetRegion(destinationRegion) helpers.FatalIfError(err) for backupState != core.VolumeBackupLifecycleStateAvailable { time.Sleep(15 * time.Second) getVolumeBackupRequest := core.GetVolumeBackupRequest{ VolumeBackupId: volumeBackup.Id, } getVolumeBackupResponse, err := destinationBS.GetVolumeBackup(context.Background(), getVolumeBackupRequest) helpers.FatalIfError(err) backupState = getVolumeBackupResponse.VolumeBackup.LifecycleState } // VolumeBackup's lifecycle state reached Available. fmt.Println("Backup copy succeeded.")
Output:
Copying backup. Copy backup request accepted waiting for the backup to be in Available state. Backup copy succeeded.
▹ Example (CreateADBsConnectionWithPrivateEndpoint)
▾ Example (CreateADBsConnectionWithPrivateEndpoint)
Example Use Case: Existing ADB-S with Private Endpoint This example creates a Database Tools Connection to a Autonomous Database (ADB-S) accessible by private endpoint (PE). Note, since this connection will be against a PE, a Database Tools Private Endpoint Reverse Connection is required. This example serves as an academic exercise of the SDK. Prerequisites: - An existing ADB-S with PE and network security group (i.e. ingress on 1522) - Available capacity (limits apply) to create a new Private Endpoint - An existing Vault for storage of secrets - A previously configured .oci/config file with a [DEFAULT] section - The following environment variables set: - OCI_DBS_OCID : The ocid for an ADB-s database - OCI_VAULT_OCID : The ocid for a vault (to store secrets) - OCI_DB_USER : The Oracle database user to connect with - OCI_DB_PASS : The Oracle database password to connect with High-level Steps: 1- Locate the Autonomous Database (ADB-S) by the provided OCID 2- Locate the Vault by the provided OCID 3- Download the wallet for the ADB-S 4- Store the secrets in the Vault (as base64 encoded strings) 5- Create a Database Tools Private Endpoint for a Reverse Connection to the Private Endpoint of the ADB-S 6- Create a Database Tools connection 7- Validate the connection ... cleanup when done (delete the temporary secrets, connection, and PE) Client | | +----------------------+----------+ | V | | +----------------+ | | | Database Tools | | | | Service | | | +----------------+ | | | | | Database | | | Tools | | | VCN | | +----------------------+----------+ | | +----------------------+----------+ | | | | V | | +-----------+ | | | Database | | | | Tools | | | | Private | | | | Endpoint | | | | Reverse | | | | Connection| | | +-----------+ | | | | | V | | +-----------+ | | | ADB-S | | | | Private | | | | Endpoint | | | +-----------+ | | | | | Customer | | | VCN | | +----------------------+----------+ | | +----------------------+----------+ | | | | V | | --------- | | / ABD-S \ | | | Private | | | \ Endpoint/ | | --------- | | | | ADB | | Shared | | VCN | +---------------------------------+
Code:
// Parses environment variables, .oci/config, and sets up the SDK clients cfg := newConfig() // Ignoring errors for simplicity privateEndpointId, _ := createDbToolsPrivateEndpoint(cfg) walletSecretId, _ := createSecretInVault(cfg.WalletBase64, cfg) passwdSecretId, _ := createSecretInVault(cfg.Password, cfg) dbConnectionId, _ := createDatabaseToolsConnectionADBs(walletSecretId, passwdSecretId, privateEndpointId, cfg) if ok := validateDatabaseToolsConnectionOracle(dbConnectionId, cfg); ok { log.Println("connection is valid") } // ... cleanup resources when finished, comment out the following delete // calls to keep the resources created above. if err := deleteConnection(dbConnectionId, cfg); err != nil { log.Printf("error deleting connection: %v\n", err) } if err := deleteSecret(passwdSecretId, cfg); err != nil { log.Printf("error deleting secret: %v\n", err) } if err := deleteSecret(walletSecretId, cfg); err != nil { log.Printf("error deleting secret: %v\n", err) } if err := deletePrivateEndpoint(privateEndpointId, cfg); err != nil { log.Printf("error deleting private endpoint: %v\n", err) } fmt.Println("Example_createADBsConnectionWithPrivateEndpoint complete")
Output:
Example_createADBsConnectionWithPrivateEndpoint complete
▹ Example (CreateADBsConnectionWithPublicIp)
▾ Example (CreateADBsConnectionWithPublicIp)
Example Use Case: Existing ADB-S with public IP (no ACL) This example creates a Database Tools Connection to an Autonomous Database (ADB) on Shared Exadata Infrastructure, accessible by public IP. Note, since this connection will be against a public IP address, a Database Tools Private Endpoint Reverse Connection is not required. Prerequisites: - An existing ADB-S - An existing Vault for storage of secrets - A previously configured .oci/config file with a [DEFAULT] section - The following environment variables set: - OCI_DBS_OCID : The ocid for an ADB-s database - OCI_VAULT_OCID : The ocid for a vault (to store secrets) - OCI_DB_USER : The Oracle database user to connect with - OCI_DB_PASS : The Oracle database password to connect with High-level Steps: 1- Locate the Autonomous Database (ADB-S) by the provided OCID 2- Locate the Vault by the provided OCID 3- Download the wallet for the ADB-S 4- Store the secrets in the Vault (as base64 encoded strings) 5- Create a Database Tools connection 6- Validate the connection ... cleanup when done (delete the temporary secrets and connection) Client | | +----------------------+----------+ | V | | +----------------+ | | | Database Tools | | | | Service | | | +----------------+ | | | | | Database | | | Tools | | | VCN | | +----------------------+----------+ | | +--------------+ | | Customer | | | VCN | | +--------------+ | | | +----------------------+----------+ | | | | V | | --------- | | / ABD-S \ | | \Public IP/ | | --------- | | | | ADB | | Shared | | VCN | +---------------------------------+
Code:
// Parses environment variables, .oci/config, and sets up the SDK clients cfg := newConfig() // Ignoring errors for simplicity walletSecretId, _ := createSecretInVault(cfg.WalletBase64, cfg) passwdSecretId, _ := createSecretInVault(cfg.Password, cfg) dbConnectionId, _ := createDatabaseToolsConnectionADBsPublicIp(walletSecretId, passwdSecretId, cfg) if ok := validateDatabaseToolsConnectionOracle(dbConnectionId, cfg); ok { log.Println("connection is valid") } // ... cleanup resources when finished, comment out the following delete // calls to keep the resources created above. if err := deleteConnection(dbConnectionId, cfg); err != nil { log.Printf("error deleting connection: %v\n", err) } if err := deleteSecret(passwdSecretId, cfg); err != nil { log.Printf("error deleting secret: %v\n", err) } if err := deleteSecret(walletSecretId, cfg); err != nil { log.Printf("error deleting secret: %v\n", err) } fmt.Println("Example_createADBsConnectionWithPublicIp complete")
Output:
Example_createADBsConnectionWithPublicIp complete
▹ Example (CreateAdb)
▾ Example (CreateAdb)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
createDbDetails := database.CreateAutonomousDatabaseDetails{
CompartmentId: helpers.CompartmentID(),
DbName: common.String("gosdkdb"),
CpuCoreCount: common.Int(1),
DataStorageSizeInTBs: common.Int(1),
AdminPassword: common.String("DBaaS12345_#"),
IsAutoScalingEnabled: common.Bool(true),
}
createadbReq := database.CreateAutonomousDatabaseRequest{
CreateAutonomousDatabaseDetails: createDbDetails,
}
_, err := c.CreateAutonomousDatabase(context.Background(), createadbReq)
helpers.FatalIfError(err)
fmt.Println("create adb successful")
Output:
create adb successful
▹ Example (CreateAdbPreview)
▾ Example (CreateAdbPreview)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
createDbDetails := database.CreateAutonomousDatabaseDetails{
CompartmentId: helpers.CompartmentID(),
DbName: common.String("gosdkPreview"),
CpuCoreCount: common.Int(1),
DataStorageSizeInTBs: common.Int(1),
AdminPassword: common.String("DBaaS12345_#"),
IsAutoScalingEnabled: common.Bool(false),
IsPreviewVersionWithServiceTermsAccepted: common.Bool(true),
}
createadbReq := database.CreateAutonomousDatabaseRequest{
CreateAutonomousDatabaseDetails: createDbDetails,
}
_, err := c.CreateAutonomousDatabase(context.Background(), createadbReq)
helpers.FatalIfError(err)
fmt.Println("create adb Preview successful")
Output:
create adb successful
▹ Example (CreateAndUseInstanceConfiguration)
▾ Example (CreateAndUseInstanceConfiguration)
Example to showcase instance configuration create and operations, and eventual teardown
Code:
package example
import (
"context"
"fmt"
"log"
"os"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/core"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
)
// Example to showcase instance configuration create and operations, and eventual teardown
func Example_createAndUseInstanceConfiguration() {
InstanceConfigsParseEnvironmentVariables()
ctx := context.Background()
computeMgmtClient, err := core.NewComputeManagementClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
computeClient, err := core.NewComputeClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
// Create instance configuration
createInstanceConfigurationResponse, _ := createInstanceConfiguration(ctx, computeMgmtClient, imageId, compartmentId)
fmt.Println("Instance configuration created")
instanceConfiguration := createInstanceConfigurationResponse.InstanceConfiguration
launchInstanceConfigResponse, _ := launchInstanceConfiguration(ctx, computeMgmtClient, *instanceConfiguration.Id, subnetId, ad)
instance := launchInstanceConfigResponse.Instance
pollUntilDesiredInstanceState(ctx, computeClient, *instance.Id)
fmt.Println("Instance launched")
createInstanceConfigFromInstanceResponse, _ := createInstanceConfigFromInstance(ctx, computeMgmtClient, *instance.Id, compartmentId)
fmt.Println("Instance configuration created from instance")
instanceConfigFromInstance := createInstanceConfigFromInstanceResponse.InstanceConfiguration
// clean up resources
defer func() {
_, _ = deleteInstanceConfiguration(ctx, computeMgmtClient, *instanceConfiguration.Id)
fmt.Println("Deleted instance configuration")
_, _ = deleteInstanceConfiguration(ctx, computeMgmtClient, *instanceConfigFromInstance.Id)
fmt.Println("Deleted instance configuration created from instance")
terminateInstance(ctx, computeClient, instance.Id)
}()
// Output:
// Instance configuration created
// Instance launched
// Instance configuration created from instance
// Deleted instance configuration
// Deleted instance configuration created from instance
// terminating instance
// instance terminated
}
func createInstanceConfigFromInstance(ctx context.Context, client core.ComputeManagementClient, instanceId string,
compartmentId string) (response core.CreateInstanceConfigurationResponse, err error) {
displayName := "Instance Config From Instance Example"
configurationDetails := core.CreateInstanceConfigurationFromInstanceDetails{
DisplayName: &displayName,
CompartmentId: &compartmentId,
InstanceId: &instanceId,
}
req := core.CreateInstanceConfigurationRequest{
CreateInstanceConfiguration: configurationDetails,
}
response, err = client.CreateInstanceConfiguration(ctx, req)
helpers.FatalIfError(err)
return
}
func launchInstanceConfiguration(ctx context.Context, client core.ComputeManagementClient, instanceConfigurationId string,
subnetId string, availabilityDomain string) (response core.LaunchInstanceConfigurationResponse, err error) {
req := core.LaunchInstanceConfigurationRequest{
InstanceConfigurationId: &instanceConfigurationId,
InstanceConfiguration: core.ComputeInstanceDetails{
LaunchDetails: &core.InstanceConfigurationLaunchInstanceDetails{
AvailabilityDomain: &availabilityDomain,
CreateVnicDetails: &core.InstanceConfigurationCreateVnicDetails{
SubnetId: &subnetId,
},
},
},
}
response, err = client.LaunchInstanceConfiguration(ctx, req)
helpers.FatalIfError(err)
return
}
func pollUntilDesiredInstanceState(ctx context.Context, client core.ComputeClient, instanceId string) {
// should retry condition check which returns a bool value indicating whether to do retry or not
// it checks the lifecycle status equals to Running or not for this case
shouldRetryFunc := func(r common.OCIOperationResponse) bool {
if converted, ok := r.Response.(core.GetInstanceResponse); ok {
return converted.LifecycleState != core.InstanceLifecycleStateRunning
}
return true
}
// create get instance request with a retry policy which takes a function
// to determine shouldRetry or not
pollingGetRequest := core.GetInstanceRequest{
InstanceId: &instanceId,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryFunc),
}
_, pollError := client.GetInstance(ctx, pollingGetRequest)
helpers.FatalIfError(pollError)
}
// Usage printing
func InstanceConfigsUsage() {
log.Printf("Please set the following environment variables to run Instance Configuration sample")
log.Printf(" ")
log.Printf(" IMAGE_ID # Required: Image Id to use")
log.Printf(" COMPARTMENT_ID # Required: Compartment Id to use")
log.Printf(" AD # Required: AD to use")
log.Printf(" SUBNET_ID # Required: Subnet to use")
log.Printf(" ")
os.Exit(1)
}
// Args parser
func InstanceConfigsParseEnvironmentVariables() {
imageId = os.Getenv("IMAGE_ID")
compartmentId = os.Getenv("COMPARTMENT_ID")
ad = os.Getenv("AD")
subnetId = os.Getenv("SUBNET_ID")
if imageId == "" ||
compartmentId == "" ||
ad == "" ||
subnetId == "" {
InstanceConfigsUsage()
}
log.Printf("IMAGE_ID : %s", imageId)
log.Printf("COMPARTMENT_ID : %s", compartmentId)
log.Printf("AD : %s", ad)
log.Printf("SUBNET_ID : %s", subnetId)
}
▹ Example (CreateAndUseSecurityTokenBasedConfiguration)
▾ Example (CreateAndUseSecurityTokenBasedConfiguration)
Code:
package example
import (
"context"
"fmt"
"log"
"os"
"os/user"
"path/filepath"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
"github.com/oracle/oci-go-sdk/v65/identity"
)
// This test requires that you have a specified profile setup for security-token based authentication, for the detail
// how to set up the configuration, please refer https://docs.oracle.com/iaas/en-us/iaas/Content/API/SDKDocs/clitoken.htm?Highlight=security_token_file
// In this example the [security_token_based_auth] is created and lists Lists the Availability Domains in current tenancy.
// The token will expire in 1 hour, user needs to check if the token is valid and then decide refresh steps via OCI CLI command.
const (
profileName = "security_token_based_auth"
cfgDirName = ".oci"
cfgFileName = "config"
)
func Example_createAndUseSecurityTokenBasedConfiguration() {
homeFolder := getHomeFolder()
configFilePath := filepath.Join(homeFolder, cfgDirName, cfgFileName)
securityTokenBasedAuthConfigProvider := common.CustomProfileConfigProvider(configFilePath, profileName)
c, err := identity.NewIdentityClientWithConfigurationProvider(securityTokenBasedAuthConfigProvider)
helpers.FatalIfError(err)
// The OCID of the tenancy containing the compartment.
tenancyID, err := securityTokenBasedAuthConfigProvider.TenancyOCID()
helpers.FatalIfError(err)
request := identity.ListAvailabilityDomainsRequest{
CompartmentId: &tenancyID,
}
r, err := c.ListAvailabilityDomains(context.Background(), request)
helpers.FatalIfError(err)
log.Printf("list of available domains: %v", r.Items)
fmt.Println("list available domains completed")
// Output:
// list available domains completed
}
func getHomeFolder() string {
current, e := user.Current()
if e != nil {
//Give up and try to return something sensible
home := os.Getenv("HOME")
if home == "" {
home = os.Getenv("USERPROFILE")
}
return home
}
return current.HomeDir
}
▹ Example (CreateAndWaitForRunningClusterNetwork)
▾ Example (CreateAndWaitForRunningClusterNetwork)
Example to showcase cluster network creation, and eventual teardown
Code:
package example
import (
"context"
"fmt"
"log"
"os"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/core"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
)
var (
clusterNetwork string
)
// Example to showcase cluster network creation, and eventual teardown
func Example_createAndWaitForRunningClusterNetwork() {
ClusterNetworkParseEnvironmentVariables()
ctx := context.Background()
computeMgmtClient, err := core.NewComputeManagementClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
createInstanceConfigurationResponse, _ := createInstanceConfigurationWithHpcShape(ctx, computeMgmtClient, imageId, compartmentId)
fmt.Println("Instance configuration created")
instanceConfiguration := createInstanceConfigurationResponse.InstanceConfiguration
clusterNetwork, _ := createClusterNetwork(ctx, computeMgmtClient, *instanceConfiguration.Id, subnetId, ad, compartmentId)
fmt.Println("Cluster Network created")
// waiting until the cluster network reaches running state
pollUntilClusterNetworkInDesiredState(ctx, computeMgmtClient, clusterNetwork, core.ClusterNetworkLifecycleStateRunning)
// clean up resources
defer func() {
terminateClusterNetwork(ctx, computeMgmtClient, *clusterNetwork.Id)
fmt.Println("Terminated Cluster Network")
deleteInstanceConfiguration(ctx, computeMgmtClient, *instanceConfiguration.Id)
fmt.Println("Deleted Instance Configuration")
}()
// Output:
// Instance configuration created
// Cluster Network created
// Cluster Network is RUNNING
// Terminated Cluster Network
// Deleted Instance Configuration
}
// Usage printing
func ClusterNetworkUsage() {
log.Printf("Please set the following environment variables to run Cluster Network sample")
log.Printf(" ")
log.Printf(" IMAGE_ID # Required: Image Id to use")
log.Printf(" COMPARTMENT_ID # Required: Compartment Id to use")
log.Printf(" AD # Required: AD to use")
log.Printf(" SUBNET_ID # Required: Subnet to use")
log.Printf(" ")
os.Exit(1)
}
// Args parser
func ClusterNetworkParseEnvironmentVariables() {
imageId = os.Getenv("IMAGE_ID")
compartmentId = os.Getenv("COMPARTMENT_ID")
ad = os.Getenv("AD")
subnetId = os.Getenv("SUBNET_ID")
if imageId == "" ||
compartmentId == "" ||
ad == "" ||
subnetId == "" {
ClusterNetworkUsage()
}
log.Printf("IMAGE_ID : %s", imageId)
log.Printf("COMPARTMENT_ID : %s", compartmentId)
log.Printf("AD : %s", ad)
log.Printf("SUBNET_ID : %s", subnetId)
}
// helper method to create a cluster network
func createClusterNetwork(ctx context.Context, client core.ComputeManagementClient, instanceConfigurationId string,
subnetId string, availabilityDomain string, compartmentId string) (response core.CreateClusterNetworkResponse, err error) {
displayName := "Cluster Network Example"
size := 1
placementConfigurationDetails := core.ClusterNetworkPlacementConfigurationDetails{
AvailabilityDomain: &availabilityDomain,
PrimarySubnetId: &subnetId,
}
req := core.CreateClusterNetworkRequest{
CreateClusterNetworkDetails: core.CreateClusterNetworkDetails{
CompartmentId: &compartmentId,
DisplayName: &displayName,
PlacementConfiguration: &placementConfigurationDetails,
InstancePools: []core.CreateClusterNetworkInstancePoolDetails{
{
Size: &size,
InstanceConfigurationId: &instanceConfigurationId,
},
},
},
}
response, err = client.CreateClusterNetwork(ctx, req)
return
}
// helper method to create an instance configuration
func createInstanceConfigurationWithHpcShape(ctx context.Context, client core.ComputeManagementClient, imageId string, compartmentId string) (response core.CreateInstanceConfigurationResponse, err error) {
vnicDetails := core.InstanceConfigurationCreateVnicDetails{}
sourceDetails := core.InstanceConfigurationInstanceSourceViaImageDetails{
ImageId: &imageId,
}
displayName := "Instance Configuration HPC Example"
shape := "BM.HPC2.36"
launchDetails := core.InstanceConfigurationLaunchInstanceDetails{
CompartmentId: &compartmentId,
DisplayName: &displayName,
CreateVnicDetails: &vnicDetails,
Shape: &shape,
SourceDetails: &sourceDetails,
}
instanceDetails := core.ComputeInstanceDetails{
LaunchDetails: &launchDetails,
}
configurationDetails := core.CreateInstanceConfigurationDetails{
DisplayName: &displayName,
CompartmentId: &compartmentId,
InstanceDetails: &instanceDetails,
}
req := core.CreateInstanceConfigurationRequest{
CreateInstanceConfiguration: configurationDetails,
}
response, err = client.CreateInstanceConfiguration(ctx, req)
helpers.FatalIfError(err)
return
}
// helper method to terminate a cluster network
func terminateClusterNetwork(ctx context.Context, client core.ComputeManagementClient,
clusterNetworkId string) (response core.TerminateClusterNetworkResponse, err error) {
req := core.TerminateClusterNetworkRequest{
ClusterNetworkId: &clusterNetworkId,
}
response, err = client.TerminateClusterNetwork(ctx, req)
helpers.FatalIfError(err)
return
}
// helper method to pool until an cluster network reaches the specified desired state
func pollUntilClusterNetworkInDesiredState(ctx context.Context, computeMgmtClient core.ComputeManagementClient,
clusterNetwork core.CreateClusterNetworkResponse, desiredState core.ClusterNetworkLifecycleStateEnum) {
// should retry condition check which returns a bool value indicating whether to do retry or not
// it checks the lifecycle status equals to Running or not for this case
shouldRetryFunc := func(r common.OCIOperationResponse) bool {
if converted, ok := r.Response.(core.GetClusterNetworkResponse); ok {
return converted.LifecycleState != desiredState
}
return true
}
// create get cluster network request with a retry policy which takes a function
// to determine shouldRetry or not
pollingGetRequest := core.GetClusterNetworkRequest{
ClusterNetworkId: clusterNetwork.Id,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryFunc),
}
_, pollError := computeMgmtClient.GetClusterNetwork(ctx, pollingGetRequest)
helpers.FatalIfError(pollError)
fmt.Println("Cluster Network is", desiredState)
}
▹ Example (CreateAndWaitForRunningInstancePool)
▾ Example (CreateAndWaitForRunningInstancePool)
Example to showcase instance pool create and operations, and eventual teardown
Code:
package example
import (
"context"
"fmt"
"log"
"os"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/core"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
)
var (
imageId, ad, subnetId, loadBalancerId, loadBalancerBackendSetName, compartmentId string
)
// Example to showcase instance pool create and operations, and eventual teardown
func Example_createAndWaitForRunningInstancePool() {
InstancePoolsParseEnvironmentVariables()
ctx := context.Background()
computeMgmtClient, err := core.NewComputeManagementClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
createInstanceConfigurationResponse, _ := createInstanceConfiguration(ctx, computeMgmtClient, imageId, compartmentId)
fmt.Println("Instance configuration created")
instanceConfiguration := createInstanceConfigurationResponse.InstanceConfiguration
instancePool, _ := createInstancePool(ctx, computeMgmtClient, *instanceConfiguration.Id, subnetId, ad, compartmentId)
fmt.Println("Instance pool created")
// waiting until the poll reaches running state
pollUntilDesiredState(ctx, computeMgmtClient, instancePool, core.InstancePoolLifecycleStateRunning)
setInstancePoolSize(ctx, computeMgmtClient, *instancePool.Id, 2)
// updating the pool size will make it go to scaling state first and then to running
pollUntilDesiredState(ctx, computeMgmtClient, instancePool, core.InstancePoolLifecycleStateScaling)
pollUntilDesiredState(ctx, computeMgmtClient, instancePool, core.InstancePoolLifecycleStateRunning)
// attach load balancer to the created pool
attachLBtoInstancePool(ctx, computeMgmtClient, *instancePool.Id, loadBalancerId, loadBalancerBackendSetName)
// poll for instance pool until the lb becomes attached
pollUntilDesiredLBAttachmentState(ctx, computeMgmtClient, instancePool, core.InstancePoolLoadBalancerAttachmentLifecycleStateAttached)
// gets the targeted load balancer information
getLbAttachmentForPool(ctx, computeMgmtClient, *instancePool.Id)
// clean up resources
defer func() {
terminateInstancePool(ctx, computeMgmtClient, *instancePool.Id)
fmt.Println("Terminated Instance Pool")
deleteInstanceConfiguration(ctx, computeMgmtClient, *instanceConfiguration.Id)
fmt.Println("Deleted Instance Configuration")
}()
// Output:
// Instance configuration created
// Instance pool created
// Instance pool is RUNNING
// Instance pool is SCALING
// Instance pool is RUNNING
// Instance pool attachment is ATTACHED
// Instance pool attachment has vnic PrimaryVnic
// Terminated Instance Pool
// Deleted Instance Configuration
}
// Usage printing
func InstancePoolsUsage() {
log.Printf("Please set the following environment variables to run Instance Pool sample")
log.Printf(" ")
log.Printf(" IMAGE_ID # Required: Image Id to use")
log.Printf(" COMPARTMENT_ID # Required: Compartment Id to use")
log.Printf(" AD # Required: AD to use")
log.Printf(" SUBNET_ID # Required: Subnet to use")
log.Printf(" LB_ID # Required: Load balancer to use")
log.Printf(" LB_BACKEND_SET_NAME # Required: Load balancer backend set name to use")
log.Printf(" ")
os.Exit(1)
}
// Args parser
func InstancePoolsParseEnvironmentVariables() {
imageId = os.Getenv("IMAGE_ID")
compartmentId = os.Getenv("COMPARTMENT_ID")
ad = os.Getenv("AD")
subnetId = os.Getenv("SUBNET_ID")
loadBalancerId = os.Getenv("LB_ID")
loadBalancerBackendSetName = os.Getenv("LB_BACKEND_SET_NAME")
if imageId == "" ||
compartmentId == "" ||
ad == "" ||
subnetId == "" ||
loadBalancerId == "" ||
loadBalancerBackendSetName == "" {
InstancePoolsUsage()
}
log.Printf("IMAGE_ID : %s", imageId)
log.Printf("COMPARTMENT_ID : %s", compartmentId)
log.Printf("AD : %s", ad)
log.Printf("SUBNET_ID : %s", subnetId)
log.Printf("LB_ID : %s", loadBalancerId)
log.Printf("LB_BACKEND_SET_NAME : %s", loadBalancerBackendSetName)
}
// helper method to create an instance configuration
func createInstanceConfiguration(ctx context.Context, client core.ComputeManagementClient, imageId string, compartmentId string) (response core.CreateInstanceConfigurationResponse, err error) {
vnicDetails := core.InstanceConfigurationCreateVnicDetails{}
sourceDetails := core.InstanceConfigurationInstanceSourceViaImageDetails{
ImageId: &imageId,
}
displayName := "Instance Configuration Example"
shape := "VM.Standard2.1"
launchDetails := core.InstanceConfigurationLaunchInstanceDetails{
CompartmentId: &compartmentId,
DisplayName: &displayName,
CreateVnicDetails: &vnicDetails,
Shape: &shape,
SourceDetails: &sourceDetails,
}
instanceDetails := core.ComputeInstanceDetails{
LaunchDetails: &launchDetails,
}
configurationDetails := core.CreateInstanceConfigurationDetails{
DisplayName: &displayName,
CompartmentId: &compartmentId,
InstanceDetails: &instanceDetails,
}
req := core.CreateInstanceConfigurationRequest{
CreateInstanceConfiguration: configurationDetails,
}
response, err = client.CreateInstanceConfiguration(ctx, req)
helpers.FatalIfError(err)
return
}
// helper method to create an instance pool
func createInstancePool(ctx context.Context, client core.ComputeManagementClient, instanceConfigurationId string,
subnetId string, availabilityDomain string, compartmentId string) (response core.CreateInstancePoolResponse, err error) {
displayName := "Instance Pool Example"
size := 1
req := core.CreateInstancePoolRequest{
CreateInstancePoolDetails: core.CreateInstancePoolDetails{
CompartmentId: &compartmentId,
InstanceConfigurationId: &instanceConfigurationId,
PlacementConfigurations: []core.CreateInstancePoolPlacementConfigurationDetails{
{
PrimarySubnetId: &subnetId,
AvailabilityDomain: &availabilityDomain,
},
},
Size: &size,
DisplayName: &displayName,
},
}
response, err = client.CreateInstancePool(ctx, req)
return
}
// helper method to terminate an instance configuration
func terminateInstancePool(ctx context.Context, client core.ComputeManagementClient,
poolId string) (response core.TerminateInstancePoolResponse, err error) {
req := core.TerminateInstancePoolRequest{
InstancePoolId: &poolId,
}
response, err = client.TerminateInstancePool(ctx, req)
helpers.FatalIfError(err)
return
}
// helper method to delete an instance configuration
func deleteInstanceConfiguration(ctx context.Context, client core.ComputeManagementClient,
instanceConfigurationId string) (response core.DeleteInstanceConfigurationResponse, err error) {
req := core.DeleteInstanceConfigurationRequest{
InstanceConfigurationId: &instanceConfigurationId,
}
response, err = client.DeleteInstanceConfiguration(ctx, req)
helpers.FatalIfError(err)
return
}
// helper method to update an instance pool size
func setInstancePoolSize(ctx context.Context, client core.ComputeManagementClient,
poolId string, newSize int) (response core.UpdateInstancePoolResponse, err error) {
updateDetails := core.UpdateInstancePoolDetails{
Size: &newSize,
}
req := core.UpdateInstancePoolRequest{
InstancePoolId: &poolId,
UpdateInstancePoolDetails: updateDetails,
}
response, err = client.UpdateInstancePool(ctx, req)
helpers.FatalIfError(err)
return
}
// helper method to update an instance pool size
func attachLBtoInstancePool(ctx context.Context, client core.ComputeManagementClient,
poolId string, loadBalancerId string, lbBackendSetName string) (response core.AttachLoadBalancerResponse, err error) {
port := 80
vnic := "PrimaryVnic"
attachDetails := core.AttachLoadBalancerDetails{
LoadBalancerId: &loadBalancerId,
BackendSetName: &loadBalancerBackendSetName,
Port: &port,
VnicSelection: &vnic,
}
req := core.AttachLoadBalancerRequest{
InstancePoolId: &poolId,
AttachLoadBalancerDetails: attachDetails,
}
response, err = client.AttachLoadBalancer(ctx, req)
helpers.FatalIfError(err)
return
}
// helper method to pool until an instance pool reaches the specified desired state
func pollUntilDesiredState(ctx context.Context, computeMgmtClient core.ComputeManagementClient,
instancePool core.CreateInstancePoolResponse, desiredState core.InstancePoolLifecycleStateEnum) {
// should retry condition check which returns a bool value indicating whether to do retry or not
// it checks the lifecycle status equals to Running or not for this case
shouldRetryFunc := func(r common.OCIOperationResponse) bool {
if converted, ok := r.Response.(core.GetInstancePoolResponse); ok {
return converted.LifecycleState != desiredState
}
return true
}
// create get instance pool request with a retry policy which takes a function
// to determine shouldRetry or not
pollingGetRequest := core.GetInstancePoolRequest{
InstancePoolId: instancePool.Id,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryFunc),
}
_, pollError := computeMgmtClient.GetInstancePool(ctx, pollingGetRequest)
helpers.FatalIfError(pollError)
fmt.Println("Instance pool is", desiredState)
}
// helper method to pool until an instance pool lb attachment reaches the specified desired state
func pollUntilDesiredLBAttachmentState(ctx context.Context, computeMgmtClient core.ComputeManagementClient,
instancePool core.CreateInstancePoolResponse, desiredState core.InstancePoolLoadBalancerAttachmentLifecycleStateEnum) {
// should retry condition check which returns a bool value indicating whether to do retry or not
// it checks the lifecycle status equals to Running or not for this case
shouldRetryFunc := func(r common.OCIOperationResponse) bool {
if converted, ok := r.Response.(core.GetInstancePoolResponse); ok {
attachments := converted.LoadBalancers
for i := range attachments {
if attachments[i].LifecycleState != desiredState {
return true
}
}
return false
}
return true
}
// create get instance pool request with a retry policy which takes a function
// to determine shouldRetry or not
pollingGetRequest := core.GetInstancePoolRequest{
InstancePoolId: instancePool.Id,
RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryFunc),
}
_, pollError := computeMgmtClient.GetInstancePool(ctx, pollingGetRequest)
helpers.FatalIfError(pollError)
fmt.Println("Instance pool attachment is", desiredState)
}
// function showing how to get lb attachment info for a pool
func getLbAttachmentForPool(ctx context.Context, computeMgmtClient core.ComputeManagementClient,
instancePoolId string) {
// gets the fresh instance pool info which, after lb attaching, now has lb attachment information
getReq := core.GetInstancePoolRequest{
InstancePoolId: &instancePoolId,
}
instancePoolResp, _ := computeMgmtClient.GetInstancePool(ctx, getReq)
// takes the 1st load balancer attachment id from the pool
lbAttachmentId := instancePoolResp.LoadBalancers[0].Id
req := core.GetInstancePoolLoadBalancerAttachmentRequest{
InstancePoolId: &instancePoolId,
InstancePoolLoadBalancerAttachmentId: lbAttachmentId,
}
response, _ := computeMgmtClient.GetInstancePoolLoadBalancerAttachment(ctx, req)
fmt.Println("Instance pool attachment has vnic", *response.VnicSelection)
}
▹ Example (CreateDataset)
▾ Example (CreateDataset)
Example_createDataset to create a dataset in a given compartment Id.
Code:
compartment := "REPLACE_WITH_COMPARTMENT_OCID"
annotationFormat := "REPLACE_WITH_ANNOTATION_FORMAT"
datasetFormat := "REPLACE_WITH_DATASET_FORMAT"
namespace := "REPLACE_WITH_OBJECT_STORAGE_NAMESPACE"
bucketName := "REPLACE_WITH_OBJECT_STORAGE_BUCKET_NAME"
displayName := "REPLACE_WITH_DATASET_DISPLAY_NAME"
labelString := "REPLACE_WITH_LABEL_NAME"
description := "REPLACE_WITH_DATASET_DESCRIPTION"
client, err := datalabelingservice.NewDataLabelingManagementClientWithConfigurationProvider(common.DefaultConfigProvider())
if err != nil {
panic(err)
}
fmt.Println("Creating dataset")
var addLabels []datalabelingservice.Label
addLabels = append(addLabels, datalabelingservice.Label{Name: common.String(labelString)})
// createDatasetRequest for the CreateDataset operation
createDatasetRequest := datalabelingservice.CreateDatasetRequest{
CreateDatasetDetails: datalabelingservice.CreateDatasetDetails{
CompartmentId: common.String(compartment),
AnnotationFormat: common.String(annotationFormat),
DatasetSourceDetails: map[string]interface{}{"sourceType": "OBJECT_STORAGE", "namespace": namespace, "bucket": bucketName},
DatasetFormatDetails: map[string]interface{}{"formatType": datasetFormat},
LabelSet: &datalabelingservice.LabelSet{Items: addLabels},
DisplayName: common.String(displayName),
Description: common.String(description),
InitialRecordGenerationConfiguration: nil,
FreeformTags: nil,
},
}
// Send the request using the service client
_, datasetErr := client.CreateDataset(context.Background(), createDatasetRequest)
helpers.FatalIfError(datasetErr)
fmt.Println("Dataset creation completed")
fmt.Println("Done")
▹ Example (CreateDbHomeBackupDestination)
▾ Example (CreateDbHomeBackupDestination)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
dbName := strings.ToLower(helpers.GetRandomString(8))
dbUniqueName := dbName + "_" + strings.ToLower(helpers.GetRandomString(20))
dbVersion := "18.0.0.0"
adminPassword := "DBaaS12345_#"
displayName := helpers.GetRandomString(32)
backupDestination := database.BackupDestinationDetails{
Type: database.BackupDestinationDetailsTypeEnum("NFS"),
Id: common.String("backup-destination-ocid"),
}
dbBackupConfig := database.DbBackupConfig{
BackupDestinationDetails: []database.BackupDestinationDetails{backupDestination},
}
// create database details
createDatabaseDetails := database.CreateDatabaseDetails{
AdminPassword: &adminPassword,
DbName: &dbName,
DbUniqueName: &dbUniqueName,
DbBackupConfig: &dbBackupConfig,
}
// create dbhome details
createDbHomeDetails := database.CreateDbHomeWithVmClusterIdDetails{
DisplayName: &displayName,
Database: &createDatabaseDetails,
VmClusterId: common.String("vm-cluster-ocid"),
DbVersion: &dbVersion,
}
// create dbome request
request := database.CreateDbHomeRequest{CreateDbHomeWithDbSystemIdDetails: createDbHomeDetails}
_, createErrors := c.CreateDbHome(context.Background(), request)
helpers.FatalIfError(createErrors)
fmt.Printf("Create DB Home with backupDestination completed")
Output:
Create DB Home with backupDestination completed
▹ Example (CreateFreeAdb)
▾ Example (CreateFreeAdb)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
createDbDetails := database.CreateAutonomousDatabaseDetails{
CompartmentId: helpers.CompartmentID(),
DbName: common.String("freeadb"),
CpuCoreCount: common.Int(1),
DataStorageSizeInTBs: common.Int(1),
AdminPassword: common.String("DBaaS12345_#"),
IsFreeTier: common.Bool(true),
}
createadbReq := database.CreateAutonomousDatabaseRequest{
CreateAutonomousDatabaseDetails: createDbDetails,
}
_, err := c.CreateAutonomousDatabase(context.Background(), createadbReq)
helpers.FatalIfError(err)
fmt.Println("create free adb successful")
Output:
create free adb successful
▹ Example (CreateGenericJdbcConnection)
▾ Example (CreateGenericJdbcConnection)
Example use case: Create a Generic JDBC connection # This example creates a Generic JDBC Database Tools Connection Prequisites: - An existing Vault for storage of secrets - A previously configured .oci/config file with a [DEFAULT] section - The following environment variable set: - OCI_VAULT_OCID : The ocid for a vault (to store secrets) High-level Steps: 1- Store the secret in the Vault (as base64 encoded strings) 2- Create the connection 3- Cleanup
Code:
cfg := newConfig() // Create the secret and validate that it was properly created passwordSecretId, _ := createSecretInVault(common.String("DatabasePassword"), cfg) if passwordSecretId == nil || cfg.getVaultCompartmentId() == nil { log.Printf("There was an error. Either the password couldn't be created or there was no defined compartment id") return } // Create a new Generic JDBC connection connectionCreationDetails := databasetools.CreateDatabaseToolsConnectionGenericJdbcDetails{ UserName: common.String("test-user"), UserPassword: databasetools.DatabaseToolsUserPasswordSecretIdDetails{SecretId: passwordSecretId}, CompartmentId: cfg.getVaultCompartmentId(), Url: common.String("jdbc:mysql://localhost:3306"), DisplayName: common.String("dbtools-temp-connection-" + helpers.GetRandomString(10)), RuntimeSupport: databasetools.RuntimeSupportUnsupported, } connectionId, err := createDatabaseToolsConnection(connectionCreationDetails, cfg) if err != nil { log.Printf("error creating the connection: %v\n", err) } // Cleanup if err := deleteSecret(passwordSecretId, cfg); err != nil { log.Printf("error deleting secret: %v\n", err) } if err := deleteConnection(connectionId, cfg); err != nil { log.Printf("error deleting connection: %v\n", err) } fmt.Println("Example_createGenericJdbcConnection complete")
Output:
Example_createGenericJdbcConnection complete
▹ Example (CreateLoadbalancer)
▾ Example (CreateLoadbalancer)
Code:
package example
import (
"context"
"fmt"
"math"
"time"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/core"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
"github.com/oracle/oci-go-sdk/v65/identity"
"github.com/oracle/oci-go-sdk/v65/loadbalancer"
)
const (
loadbalancerDisplayName = "OCI-GO-Sample-LB"
nsgDisplayNameOne = "OCI-GOSDK-Sample-NSG-1"
nsgDisplayNameTwo = "OCI-GOSDK-Sample-NSG-2"
listenerDisplayName = "GO_SDK_Listener"
rulesetOneName = "ruleset1"
backendSetOneName = "backendset1"
cipherName = "test-cipher"
certificateName = "example-certificate"
publicCert = `-----BEGIN CERTIFICATE-----
publicKeyGoesHere
-----END CERTIFICATE-----`
privateKey = `-----BEGIN RSA PRIVATE KEY-----
PrivateKeyGoesHere
-----END RSA PRIVATE KEY-----`
)
func Example_createLoadbalancer() {
c, clerr := loadbalancer.NewLoadBalancerClientWithConfigurationProvider(common.DefaultConfigProvider())
ctx := context.Background()
helpers.FatalIfError(clerr)
request := loadbalancer.CreateLoadBalancerRequest{}
request.CompartmentId = helpers.CompartmentID()
request.DisplayName = common.String(loadbalancerDisplayName)
subnet1 := CreateOrGetSubnet()
fmt.Println("create subnet1 complete")
// create a subnet in different availability domain
identityClient, err := identity.NewIdentityClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
req := identity.ListAvailabilityDomainsRequest{}
req.CompartmentId = helpers.CompartmentID()
response, err := identityClient.ListAvailabilityDomains(ctx, req)
helpers.FatalIfError(err)
availableDomain := response.Items[1].Name
subnet2 := CreateOrGetSubnetWithDetails(common.String(subnetDisplayName2), common.String("10.0.1.0/24"), common.String("subnetdns2"), availableDomain)
fmt.Println("create subnet2 complete")
request.SubnetIds = []string{*subnet1.Id, *subnet2.Id}
shapes := listLoadBalancerShapes(ctx, c)
fmt.Println("list load balancer shapes complete")
request.ShapeName = shapes[0].Name
// Create rulesets to modify response / request headers or control access types based on REST request
ruleSets := map[string]loadbalancer.RuleSetDetails{
rulesetOneName: {
Items: []loadbalancer.Rule{
loadbalancer.AddHttpRequestHeaderRule{
Header: common.String("some-header-name-to-add"),
Value: common.String("some-value-for-header"),
},
loadbalancer.RemoveHttpResponseHeaderRule{
Header: common.String("some-header-name-to-remove"),
},
loadbalancer.ExtendHttpRequestHeaderValueRule{
Header: common.String("some-other-header-name-to-alter"),
Prefix: common.String("some-prefix-value-for-header"),
Suffix: common.String("some-suffix-value-for-header"),
},
loadbalancer.AllowRule{
Description: common.String("Allow traffic from internet clients"),
Conditions: []loadbalancer.RuleCondition{
loadbalancer.SourceIpAddressCondition{
AttributeValue: common.String("111.111.111.111/32"),
},
},
},
loadbalancer.ControlAccessUsingHttpMethodsRule{
AllowedMethods: []string{
"PUT",
"POST",
},
StatusCode: common.Int(403),
},
}},
}
request.RuleSets = ruleSets
// ssl cipher suites for the load balancer
sslCiphers := map[string]loadbalancer.SslCipherSuiteDetails{
cipherName: {
Name: common.String(cipherName),
Ciphers: []string{"AES128-SHA", "AES256-SHA"},
},
}
request.SslCipherSuites = sslCiphers
cert := map[string]loadbalancer.CertificateDetails{
certificateName: {
CertificateName: common.String(certificateName),
PrivateKey: common.String(privateKey),
PublicCertificate: common.String(publicCert),
CaCertificate: common.String(publicCert),
},
}
request.Certificates = cert
// Backend Sets for our new LB. Includes an LB Cookie session persistence configuration. Note that this is
// mutually exclusive with a session persistence configuration.
backendSets := map[string]loadbalancer.BackendSetDetails{
backendSetOneName: {
Policy: common.String("ROUND_ROBIN"),
HealthChecker: &loadbalancer.HealthCheckerDetails{
Protocol: common.String("HTTP"),
UrlPath: common.String("/health"),
Port: common.Int(80),
},
Backends: []loadbalancer.BackendDetails{
{
IpAddress: common.String("10.11.10.5"),
Port: common.Int(80),
},
{
IpAddress: common.String("10.12.20.3"),
Port: common.Int(80),
},
},
LbCookieSessionPersistenceConfiguration: &loadbalancer.LbCookieSessionPersistenceConfigurationDetails{
CookieName: common.String("X-Oracle-OCI-cookie-1"),
DisableFallback: common.Bool(true),
Domain: common.String("www.example.org"),
Path: common.String("/cookiepath1"),
MaxAgeInSeconds: common.Int(300),
IsSecure: common.Bool(false),
IsHttpOnly: common.Bool(false),
},
SslConfiguration: &loadbalancer.SslConfigurationDetails{
CertificateName: common.String("example-certificate"),
VerifyPeerCertificate: common.Bool(true),
CipherSuiteName: common.String(cipherName),
Protocols: []string{"TLSv1.1"},
},
},
}
request.BackendSets = backendSets
listeners := map[string]loadbalancer.ListenerDetails{
listenerDisplayName: {
DefaultBackendSetName: common.String(backendSetOneName),
Port: common.Int(80),
Protocol: common.String("HTTP"),
RuleSetNames: []string{rulesetOneName},
SslConfiguration: &loadbalancer.SslConfigurationDetails{
CertificateName: common.String("example-certificate"),
VerifyPeerCertificate: common.Bool(true),
CipherSuiteName: common.String(cipherName),
Protocols: []string{"TLSv1.1"},
},
},
}
request.Listeners = listeners
_, err = c.CreateLoadBalancer(ctx, request)
helpers.FatalIfError(err)
fmt.Println("create load balancer complete")
// get created loadbalancer
getLoadBalancer := func() *loadbalancer.LoadBalancer {
loadbalancers := listLoadBalancers(ctx, c, loadbalancer.LoadBalancerLifecycleStateActive)
for _, element := range loadbalancers {
if *element.DisplayName == loadbalancerDisplayName {
// found it, return
return &element
}
}
return nil
}
attempts := uint(10)
retryIfLBNotReady := func(r common.OCIOperationResponse) bool {
loadBalancer := getLoadBalancer()
if loadBalancer != nil {
fieldLifecycle, err := helpers.FindLifecycleFieldValue(loadBalancer)
if err != nil {
common.Logf("Error getting lifecycleState. Error is %v", err)
return true
}
lifecycleState := string(loadbalancer.LoadBalancerLifecycleStateActive)
isEqual := fieldLifecycle == lifecycleState
if isEqual {
return false
}
common.Logf("Current lifecycle state is %s, waiting for it to become %s", fieldLifecycle, lifecycleState)
return true
}
common.Logf("LB not available, waiting...")
return true
}
nextDuration := func(r common.OCIOperationResponse) time.Duration {
// this function will return the duration as:
// 1s, 2s, 4s, 8s, 16s, 32s, 64s etc...
return time.Duration(math.Pow(float64(2), float64(r.AttemptNumber-1))) * time.Second
}
defaultRetryPolicy := common.NewRetryPolicy(attempts, retryIfLBNotReady, nextDuration)
request.RequestMetadata = common.RequestMetadata{
RetryPolicy: &defaultRetryPolicy,
}
_, err = c.CreateLoadBalancer(ctx, request)
helpers.FatalIfError(err)
newCreatedLoadBalancer := getLoadBalancer()
fmt.Printf("New loadbalancer LifecycleState is: %s\n\n", newCreatedLoadBalancer.LifecycleState)
//Update cipher suites
updateSSLCiphers(ctx, c, newCreatedLoadBalancer.Id)
loadBalancerRuleSets := listRuleSets(ctx, c, newCreatedLoadBalancer.Id)
fmt.Printf("Rule Sets from GET: %+v\n\n", loadBalancerRuleSets)
newRuleSetResponse, err := addRuleSet(ctx, c, newCreatedLoadBalancer.Id)
fmt.Printf("New rule set response: %+v\n\n", newRuleSetResponse)
newBackendSetResponse, err := addBackendSet(ctx, c, newCreatedLoadBalancer.Id)
fmt.Printf("New backend set: %+v\n\n", newBackendSetResponse)
getListenerRulesResponse := listListenerRules(ctx, c, newCreatedLoadBalancer.Id, common.String(listenerDisplayName))
fmt.Printf("Listener Rules: %+v\n\n", getListenerRulesResponse)
vnClient, vclerr := core.NewVirtualNetworkClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(vclerr)
vcnId := subnet1.VcnId
nsg1 := createNsg(ctx, vnClient, nsgDisplayNameOne, helpers.CompartmentID(), vcnId)
nsg2 := createNsg(ctx, vnClient, nsgDisplayNameTwo, helpers.CompartmentID(), vcnId)
var nsgArray = []string{*(nsg1.Id), *(nsg2.Id)}
// Change Compartment (Requires second compartment to move the LB into)
secondCompartmentId := helpers.RootCompartmentID()
changeCompartmentResponse, err := changeLBCompartment(ctx, c, newCreatedLoadBalancer.Id, secondCompartmentId)
fmt.Printf("Load balancer compartment changed: %+v", changeCompartmentResponse)
//Update nsg call
updateNsgWithLbr(ctx, c, newCreatedLoadBalancer.Id, nsgArray)
// clean up resources
defer func() {
deleteLoadbalancer(ctx, c, newCreatedLoadBalancer.Id)
vcnID := subnet1.VcnId
deleteSubnet(ctx, vnClient, subnet1.Id)
deleteSubnet(ctx, vnClient, subnet2.Id)
deleteNsg(ctx, vnClient, nsg1.Id)
deleteNsg(ctx, vnClient, nsg2.Id)
deleteVcn(ctx, vnClient, vcnID)
}()
// Output:
// create subnet1 complete
// create subnet2 complete
// list load balancer shapes complete
// create load balancer complete
// new loadbalancer LifecycleState is: ACTIVE
// Rule Sets from GET: {}
// New rule set response: {}
// New backend set: {}
// deleting load balancer
// load balancer deleted
// deleteing subnet
// subnet deleted
// deleteing subnet
// subnet deleted
// deleteing VCN
// VCN deleted
}
func listLoadBalancerShapes(ctx context.Context, client loadbalancer.LoadBalancerClient) []loadbalancer.LoadBalancerShape {
request := loadbalancer.ListShapesRequest{
CompartmentId: helpers.CompartmentID(),
}
r, err := client.ListShapes(ctx, request)
helpers.FatalIfError(err)
return r.Items
}
func listLoadBalancers(ctx context.Context, client loadbalancer.LoadBalancerClient, lifecycleState loadbalancer.LoadBalancerLifecycleStateEnum) []loadbalancer.LoadBalancer {
request := loadbalancer.ListLoadBalancersRequest{
CompartmentId: helpers.CompartmentID(),
DisplayName: common.String(loadbalancerDisplayName),
LifecycleState: lifecycleState,
}
r, err := client.ListLoadBalancers(ctx, request)
helpers.FatalIfError(err)
return r.Items
}
func deleteLoadbalancer(ctx context.Context, client loadbalancer.LoadBalancerClient, id *string) {
request := loadbalancer.DeleteLoadBalancerRequest{
LoadBalancerId: id,
}
_, err := client.DeleteLoadBalancer(ctx, request)
helpers.FatalIfError(err)
fmt.Println("deleting load balancer")
// get loadbalancer
getLoadBalancer := func() *loadbalancer.LoadBalancer {
loadbalancers := listLoadBalancers(ctx, client, loadbalancer.LoadBalancerLifecycleStateDeleting)
for _, element := range loadbalancers {
if *element.DisplayName == loadbalancerDisplayName {
// found it, return
return &element
}
}
return nil
}
// use to check the lifecycle state of load balancer
loadBalancerLifecycleStateCheck := func() (interface{}, error) {
loadBalancer := getLoadBalancer()
if loadBalancer != nil {
return loadBalancer, nil
}
// cannot find load balancer which means it's been deleted
return loadbalancer.LoadBalancer{LifecycleState: loadbalancer.LoadBalancerLifecycleStateDeleted}, nil
}
// wait for load balancer been deleted
helpers.FatalIfError(
helpers.RetryUntilTrueOrError(
loadBalancerLifecycleStateCheck,
helpers.CheckLifecycleState(string(loadbalancer.LoadBalancerLifecycleStateDeleted)),
time.Tick(10*time.Second),
time.After((10 * time.Minute))))
fmt.Println("load balancer deleted")
}
// Add a new ruleset to an existing LB
func addRuleSet(ctx context.Context, client loadbalancer.LoadBalancerClient, id *string) (loadbalancer.CreateRuleSetResponse, error) {
request := loadbalancer.CreateRuleSetRequest{}
request.LoadBalancerId = id
ruleSetDetails := loadbalancer.CreateRuleSetDetails{
Name: common.String("ruleset2"),
Items: []loadbalancer.Rule{
loadbalancer.AddHttpResponseHeaderRule{
Header: common.String("some-second-header-name-to-add"),
Value: common.String("some-second-value-for-header"),
},
loadbalancer.RemoveHttpRequestHeaderRule{
Header: common.String("some-second-header-name-to-remove"),
},
},
}
request.CreateRuleSetDetails = ruleSetDetails
response, err := client.CreateRuleSet(ctx, request)
helpers.FatalIfError(err)
println("ruleset added")
return response, err
}
// Get a list of rulesets from a given LB
func listRuleSets(ctx context.Context, client loadbalancer.LoadBalancerClient, id *string) []loadbalancer.RuleSet {
request := loadbalancer.ListRuleSetsRequest{
LoadBalancerId: id,
}
r, err := client.ListRuleSets(ctx, request)
helpers.FatalIfError(err)
return r.Items
}
// Add a new backend set to an existing LB
func addBackendSet(ctx context.Context, client loadbalancer.LoadBalancerClient, id *string) (loadbalancer.CreateBackendSetResponse, error) {
request := loadbalancer.CreateBackendSetRequest{}
request.LoadBalancerId = id
backendSetDetails := loadbalancer.CreateBackendSetDetails{
Name: common.String("backendset2"),
Policy: common.String("ROUND_ROBIN"),
HealthChecker: &loadbalancer.HealthCheckerDetails{
Protocol: common.String("HTTP"),
UrlPath: common.String("/health"),
Port: common.Int(80),
},
Backends: []loadbalancer.BackendDetails{
{
IpAddress: common.String("10.11.10.5"),
Port: common.Int(80),
},
{
IpAddress: common.String("10.12.20.3"),
Port: common.Int(80),
},
},
LbCookieSessionPersistenceConfiguration: &loadbalancer.LbCookieSessionPersistenceConfigurationDetails{
CookieName: common.String("X-Oracle-OCI-cookie-2"),
DisableFallback: common.Bool(true),
Domain: common.String("www.example.org"),
Path: common.String("/cookiepath2"),
MaxAgeInSeconds: common.Int(300),
IsSecure: common.Bool(false),
IsHttpOnly: common.Bool(false),
},
}
request.CreateBackendSetDetails = backendSetDetails
response, err := client.CreateBackendSet(ctx, request)
helpers.FatalIfError(err)
println("backendset added")
return response, err
}
// Update ssl ciphers
func updateSSLCiphers(ctx context.Context, c loadbalancer.LoadBalancerClient, loadBalancerId *string) {
request := loadbalancer.UpdateSSLCipherSuiteRequest{
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
details := loadbalancer.UpdateSslCipherSuiteDetails{
Ciphers: []string{"ECDHE-ECDSA-AES256-GCM-SHA384"},
}
request.LoadBalancerId = loadBalancerId
request.UpdateSslCipherSuiteDetails = details
_, err := c.UpdateSSLCipherSuite(ctx, request)
helpers.FatalIfError(err)
}
// Create network security group
func createNsg(ctx context.Context, c core.VirtualNetworkClient, displayName string, compartmentId, vcnId *string) core.NetworkSecurityGroup {
// create a new nsg
createNsgRequest := core.CreateNetworkSecurityGroupRequest{
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
cnsgDetails := core.CreateNetworkSecurityGroupDetails{}
cnsgDetails.CompartmentId = compartmentId
cnsgDetails.DisplayName = common.String(displayName)
cnsgDetails.VcnId = vcnId
createNsgRequest.CreateNetworkSecurityGroupDetails = cnsgDetails
r, err := c.CreateNetworkSecurityGroup(ctx, createNsgRequest)
helpers.FatalIfError(err)
return r.NetworkSecurityGroup
}
// Delete network security group
func deleteNsg(ctx context.Context, c core.VirtualNetworkClient, nsgId *string) {
//delete the nsg
deleteNsgRequest := core.DeleteNetworkSecurityGroupRequest{
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
deleteNsgRequest.NetworkSecurityGroupId = nsgId
_, err := c.DeleteNetworkSecurityGroup(ctx, deleteNsgRequest)
helpers.FatalIfError(err)
}
// Update nsg list with load balancer
func updateNsgWithLbr(ctx context.Context, c loadbalancer.LoadBalancerClient, loadBalancerId *string, networkSecurityGroupIds []string) {
request := loadbalancer.UpdateNetworkSecurityGroupsRequest{
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
details := loadbalancer.UpdateNetworkSecurityGroupsDetails{
NetworkSecurityGroupIds: networkSecurityGroupIds,
}
request.LoadBalancerId = loadBalancerId
request.UpdateNetworkSecurityGroupsDetails = details
_, err := c.UpdateNetworkSecurityGroups(ctx, request)
helpers.FatalIfError(err)
}
// List Listener Rules for a given listener (by load balancer id and listener name)
func listListenerRules(ctx context.Context, client loadbalancer.LoadBalancerClient, id *string, name *string) []loadbalancer.ListenerRuleSummary {
request := loadbalancer.ListListenerRulesRequest{
LoadBalancerId: id,
ListenerName: name,
}
r, err := client.ListListenerRules(ctx, request)
helpers.FatalIfError(err)
return r.Items
}
// Move the LB to a new compartment
func changeLBCompartment(ctx context.Context, client loadbalancer.LoadBalancerClient, id *string, compartmentId *string) (loadbalancer.ChangeLoadBalancerCompartmentResponse, error) {
request := loadbalancer.ChangeLoadBalancerCompartmentRequest{}
request.LoadBalancerId = id
changeCompartmentDetails := loadbalancer.ChangeLoadBalancerCompartmentDetails{
CompartmentId: compartmentId,
}
request.ChangeLoadBalancerCompartmentDetails = changeCompartmentDetails
response, err := client.ChangeLoadBalancerCompartment(ctx, request)
helpers.FatalIfError(err)
return response, err
}
▹ Example (CreateMySqlConnectionWithPublicIp)
▾ Example (CreateMySqlConnectionWithPublicIp)
Example Use Case: Existing MySQL database with public IP (customer-managed) This example creates a Database Tools Connection to a MySQL database accessible by public IP. Note, since this connection will be against a public IP address, a Database Tools Private Endpoint Reverse Connection is not required. Exposing a database directly to the Internet is not a recommended practice for security reasons. This example serves as an academic exercise of the SDK and proof of concept only. Prerequisites: - An existing MySQL database on a compute node, for example - Firewall or security list entries allowing TCP traffic to MySQL - An existing Vault for storage of secrets - A previously configured .oci/config file with a [DEFAULT] section - The following environment variables set: - OCI_VAULT_OCID : The ocid for a vault (to store secrets) - OCI_DB_USER : The MySQL database user to connect with - OCI_DB_PASS : The MySQL database password to connect with - OCI_CONN_STRING : The MySQL connection string, asin mysql://host:port High-level Steps: 1- Locate the Vault by the provided OCID 2- Store the secret in the Vault (as base64 encoded string) 3- Create a Database Tools Connection 4- Validate the connection ... cleanup when done (delete the temporary secret and connection) Client | | +----------------------+----------+ | V | | +----------------+ | | | Database Tools | | | | Service | | | +----------------+ | | | | | Database | | | Tools | | | VCN | | +----------------------+----------+ | | +----------------------+----------+ | Compute | | | Node | | | | | | | | | V | | --------- | | / MySQL \ | | \Public IP/ | | --------- | | | +---------------------------------+
Code:
// Parses environment variables, .oci/config, and sets up the SDK clients cfg := newConfig() // Ignoring errors for simplicity passwdSecretId, _ := createSecretInVault(cfg.Password, cfg) dbConnectionId, _ := createDatabaseToolsConnectionMySqlPublicIp(passwdSecretId, cfg) if ok := validateDatabaseToolsConnectionMySQL(dbConnectionId, cfg); ok { log.Println("connection is valid") } // ... cleanup resources when finished, comment out the following delete // calls to keep the resources created above. if err := deleteConnection(dbConnectionId, cfg); err != nil { log.Printf("error deleting connection: %v\n", err) } if err := deleteSecret(passwdSecretId, cfg); err != nil { log.Printf("error deleting secret: %v\n", err) } fmt.Println("Example_createMySqlConnectionWithPublicIp complete")
Output:
Example_createMySqlConnectionWithPublicIp complete
▹ Example (CreateMySqlDbSystemConnectionWithPrivateEndpoint)
▾ Example (CreateMySqlDbSystemConnectionWithPrivateEndpoint)
Example Use Case: MySQL DB System with Database Tools Private Endpoint This example creates a Database Tools Connection to a MySQL DB System accessible by private IP. Note, since this connection will be against a private IP address, a Database Tools Private Endpoint Reverse Connection is required. This example serves as an academic exercise of the SDK. Prerequisites: - An existing MySQL DB System in a VCN and associated subnet - Available capacity (limits apply) to create a new Private Endpoint - An existing Vault for storage of secrets - A previously configured .oci/config file with a [DEFAULT] section - The following environment variables set: - OCI_DBS_OCID : The ocid for a MySQL DB System - OCI_VAULT_OCID : The ocid for a vault (to store secrets) - OCI_DB_USER : The MySQL database user to connect with - OCI_DB_PASS : The MySQL database password to connect with High-level Steps: 1- Locate the MySQL DB System by provided OCID 2- Locate the Vault by provided OCID 3- Store the secret in the Vault (as base64 encoded string) 4- Create a Database Tools Private Endpoint Reverse Connection 5- Create a Database Tools connection 6- Validate the connection ... cleanup when done (delete the temporary secret, connection, and PE) Client | | +----------------------+----------+ | V | | +----------------+ | | | Database Tools | | | | Service | | | +----------------+ | | | | | Database | | | Tools | | | VCN | | +----------------------+----------+ | | +----------------------+----------+ | | | | V | | +-----------+ | | | Database | | | | Tools | | | | Private | | | | Endpoint | | | +-----------+ | | | | | | | | V | | --------- | | / MDS \ | | | Private | | | \ IP / | | --------- | | | | Customer | | VCN (jump host not required) | +---------------------------------+
Code:
// Parses environment variables, .oci/config, and sets up the SDK clients cfg := newConfig() // Ignoring errors for simplicity privateEndpointId, _ := createDbToolsPrivateEndpoint(cfg) passwdSecretId, _ := createSecretInVault(cfg.Password, cfg) dbConnectionId, _ := createDatabaseToolsConnectionMySql(passwdSecretId, privateEndpointId, cfg) if ok := validateDatabaseToolsConnectionMySQL(dbConnectionId, cfg); ok { log.Println("connection is valid") } // ... cleanup resources when finished, comment out the following delete // calls to keep the resources created above. if err := deleteConnection(dbConnectionId, cfg); err != nil { log.Printf("error deleting connection: %v\n", err) } if err := deleteSecret(passwdSecretId, cfg); err != nil { log.Printf("error deleting secret: %v\n", err) } if err := deletePrivateEndpoint(privateEndpointId, cfg); err != nil { log.Printf("error deleting private endpoint: %v\n", err) } fmt.Println("Example_createMySqlDbSystemConnectionWithPrivateEndpoint complete")
Output:
Example_createMySqlDbSystemConnectionWithPrivateEndpoint complete
▹ Example (CreateNFSBackupDestination)
▾ Example (CreateNFSBackupDestination)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
displayNameBackupDestination := helpers.GetRandomString(32)
compartmentId := os.Getenv("OCI_COMPARTMENT_ID")
createBackupDestinationDetails := database.CreateNfsBackupDestinationDetails{
CompartmentId: &compartmentId,
DisplayName: &displayNameBackupDestination,
LocalMountPointPath: common.String("path"),
}
createbackupdestinationReq := database.CreateBackupDestinationRequest{
CreateBackupDestinationDetails: createBackupDestinationDetails,
}
_, err := c.CreateBackupDestination(context.Background(), createbackupdestinationReq)
helpers.FatalIfError(err)
fmt.Println("create backup destination is successful")
Output:
create backup destination is successful
▹ Example (CreateRecord)
▾ Example (CreateRecord)
Code:
datasetId := "REPLACE_WITH_DATASET_OCID"
compartment := "REPLACE_WITH_COMPARTMENT_OCID"
namespace := "REPLACE_WITH_OBJECT_STORAGE_NAMESPACE"
bucketName := "REPLACE_WITH_OBJECT_STORAGE_BUCKET_NAME"
objectName := "REPLACE_WITH_OBJECT_NAME"
client, err := datalabelingservicedataplane.NewDataLabelingClientWithConfigurationProvider(common.DefaultConfigProvider())
if err != nil {
panic(err)
}
fmt.Println("Record creation")
objectPath := fmt.Sprintf("/n/%s/b/%s/o/%s", namespace, bucketName, objectName)
sourceDetails := datalabelingservicedataplane.ObjectStorageSourceDetails{
RelativePath: common.String(objectName),
Path: common.String(objectPath),
}
name := common.String(objectName)
createRecordRequest := datalabelingservicedataplane.CreateRecordRequest{
CreateRecordDetails: datalabelingservicedataplane.CreateRecordDetails{
Name: name,
DatasetId: common.String(datasetId),
CompartmentId: common.String(compartment),
SourceDetails: sourceDetails,
FreeformTags: nil,
DefinedTags: nil,
},
OpcRetryToken: nil,
OpcRequestId: nil,
RequestMetadata: common.RequestMetadata{},
}
_, recordErr := client.CreateRecord(context.Background(), createRecordRequest)
helpers.FatalIfError(recordErr)
fmt.Println("Record creation succeeded")
Output:
Record creation. Record creation succeeded.
▹ Example (CreateServiceGateway)
▾ Example (CreateServiceGateway)
Code:
displayName := "OCI-GOSDK-CreateServiceGateway-Example" // displayName for created VCN and ServiceGateway compartmentID := os.Getenv("OCI_COMPARTMENT_ID") // OCI_COMPARTMENT_ID env variable must be defined // initialize VirtualNetworkClient client, err := core.NewVirtualNetworkClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(err) ctx := context.Background() // create VCN createVcnRequest := core.CreateVcnRequest{ RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(), } createVcnRequest.CompartmentId = common.String(compartmentID) createVcnRequest.DisplayName = common.String(displayName) createVcnRequest.CidrBlock = common.String("10.0.0.0/16") createVcnResponse, err := client.CreateVcn(ctx, createVcnRequest) helpers.FatalIfError(err) // create ServiceGateway createServiceGatewayRequest := core.CreateServiceGatewayRequest{ RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(), } createServiceGatewayRequest.CompartmentId = common.String(compartmentID) createServiceGatewayRequest.DisplayName = common.String(displayName) createServiceGatewayRequest.VcnId = createVcnResponse.Id createServiceGatewayRequest.Services = []core.ServiceIdRequestDetails{} _, err = client.CreateServiceGateway(ctx, createServiceGatewayRequest) helpers.FatalIfError(err) fmt.Println("ServiceGateway created")
Output:
ServiceGateway created
▹ Example (CreateVcn)
▾ Example (CreateVcn)
Code:
displayName := "OCI-GOSDK-CreateVcn-Example"
compartmentID := os.Getenv("OCI_COMPARTMENT_ID") // OCI_COMPARTMENT_ID env variable must be defined
// initialize VirtualNetworkClient
client, err := core.NewVirtualNetworkClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
ctx := context.Background()
// create VCN
createVcnRequest := core.CreateVcnRequest{
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
createVcnRequest.CompartmentId = common.String(compartmentID)
createVcnRequest.DisplayName = common.String(displayName)
createVcnRequest.CidrBlock = common.String("10.0.0.0/16")
_, err = client.CreateVcn(ctx, createVcnRequest)
helpers.FatalIfError(err)
fmt.Println("VCN created")
Output:
VCN created
▹ Example (CryptoOperations)
▾ Example (CryptoOperations)
Code:
vaultClient, clientError := keymanagement.NewKmsVaultClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(clientError) ctx := context.Background() vaultName := "KmsVault" keyName := "KmsKey" testInput := "CryptoOps Test Input" vault := createVault(ctx, vaultClient, vaultName) defer cleanupResources(ctx, vaultClient, vault.Id) // wait for instance lifecycle state becomes active waitForStateVaultClient(ctx, vault.Id, vaultClient, keymanagement.VaultLifecycleStateActive) vaultManagementClient, mgmtClientError := keymanagement. NewKmsManagementClientWithConfigurationProvider(common.DefaultConfigProvider(), *vault.ManagementEndpoint) helpers.FatalIfError(mgmtClientError) // Create Key key, keyShape := createKey(ctx, vaultManagementClient, &keyName) // Create crypto client vaultCryptoClient, cryptoClientError := keymanagement. NewKmsCryptoClientWithConfigurationProvider(common.DefaultConfigProvider(), *vault.CryptoEndpoint) helpers.FatalIfError(cryptoClientError) // Generate DEK includePlaintextKeyInResponse := true generateKeyDetails := keymanagement.GenerateKeyDetails{ KeyId: key.Id, KeyShape: &keyShape, IncludePlaintextKey: &includePlaintextKeyInResponse, } generateDekRequest := keymanagement.GenerateDataEncryptionKeyRequest{ GenerateKeyDetails: generateKeyDetails, } generateDekResponse, err := vaultCryptoClient.GenerateDataEncryptionKey(ctx, generateDekRequest) helpers.FatalIfError(err) generatedKey := generateDekResponse.GeneratedKey fmt.Printf("Plaintext generated DEK: %s\n", *generatedKey.Plaintext) fmt.Println("generate DEK") // Encrypt encryptedDataDetails := keymanagement.EncryptDataDetails{ KeyId: key.Id, Plaintext: &testInput, } encryptRequest := keymanagement.EncryptRequest{ EncryptDataDetails: encryptedDataDetails, } encryptResponse, encryptErr := vaultCryptoClient.Encrypt(ctx, encryptRequest) helpers.FatalIfError(encryptErr) cipherText := encryptResponse.Ciphertext fmt.Print("encrypt data") // Decrypt decryptDataDetails := keymanagement.DecryptDataDetails{ KeyId: key.Id, Ciphertext: cipherText, } decryptRequest := keymanagement.DecryptRequest{ DecryptDataDetails: decryptDataDetails, } decryptResponse, decryptErr := vaultCryptoClient.Decrypt(ctx, decryptRequest) helpers.FatalIfError(decryptErr) plainText := decryptResponse.Plaintext fmt.Printf("Decrypted plaintext: %s\n", *plainText) fmt.Print("decrypt data")
Output:
create vault create key Plaintext generated DEK: <generated key> generate DEK encrypt data Decrypted plaintext: CryptoOps Test Input decrypt data schedule vault deletion
▹ Example (CustomRetry)
▾ Example (CustomRetry)
Example_customRetry shows how to use retry for Create and Delete groups, please refer to example_core_test.go->Example_launchInstance for more examples
Code:
// create and delete group with retry client, clerr := identity.NewIdentityClientWithConfigurationProvider(common.DefaultConfigProvider()) ctx := context.Background() helpers.FatalIfError(clerr) request := identity.CreateGroupRequest{} request.CompartmentId = helpers.RootCompartmentID() request.Name = common.String("GoSDK_Sample_Group") request.Description = common.String("GoSDK Sample Group Description") // maximum times of retry attempts := uint(10) // retry for all non-200 status code retryOnAllNon200ResponseCodes := func(r common.OCIOperationResponse) bool { return !(r.Error == nil && 199 < r.Response.HTTPResponse().StatusCode && r.Response.HTTPResponse().StatusCode < 300) } customRetryPolicy := common.NewRetryPolicyWithOptions( // since this retries on ANY non-2xx response, we don't need special handling for eventual consistency common.ReplaceWithValuesFromRetryPolicy(common.DefaultRetryPolicyWithoutEventualConsistency()), common.WithMaximumNumberAttempts(attempts), common.WithShouldRetryOperation(retryOnAllNon200ResponseCodes), ) // create request metadata for retry request.RequestMetadata = common.RequestMetadata{ RetryPolicy: &customRetryPolicy, } resp, err := client.CreateGroup(ctx, request) helpers.FatalIfError(err) fmt.Println("Creating Group") // Get with polling shouldRetry := func(r common.OCIOperationResponse) bool { if _, isServiceError := common.IsServiceError(r.Error); isServiceError { // not service error, could be network error or other errors which prevents // request send to server, will do retry here return true } if converted, ok := r.Response.(identity.GetGroupResponse); ok { // do the retry until lifecycle state become active return converted.LifecycleState != identity.GroupLifecycleStateActive } return true } lifecycleStateCheckRetryPolicy := common.NewRetryPolicyWithOptions( // since this retries on ANY error response, we don't need special handling for eventual consistency common.ReplaceWithValuesFromRetryPolicy(common.DefaultRetryPolicyWithoutEventualConsistency()), common.WithMaximumNumberAttempts(attempts), common.WithShouldRetryOperation(shouldRetry), ) getRequest := identity.GetGroupRequest{ GroupId: resp.Id, RequestMetadata: common.RequestMetadata{ RetryPolicy: &lifecycleStateCheckRetryPolicy, }, } _, errAfterPolling := client.GetGroup(ctx, getRequest) helpers.FatalIfError(errAfterPolling) fmt.Println("Group Created") defer func() { // if we've successfully created a group, make sure that we delete it rDel := identity.DeleteGroupRequest{ GroupId: resp.Id, RequestMetadata: common.RequestMetadata{ RetryPolicy: &customRetryPolicy, }, } _, err = client.DeleteGroup(ctx, rDel) helpers.FatalIfError(err) fmt.Println("Group Deleted") }()
Output:
Creating Group Group Created Group Deleted
▹ Example (DeleteBackupDestination)
▾ Example (DeleteBackupDestination)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
deletebackupDestinationReq := database.DeleteBackupDestinationRequest{
BackupDestinationId: common.String("backup-destination-ocid"),
}
_, err := c.DeleteBackupDestination(context.Background(), deletebackupDestinationReq)
helpers.FatalIfError(err)
fmt.Println("delete backup destination is successful")
Output:
delete backup destination is successful
▹ Example (DeleteDataset)
▾ Example (DeleteDataset)
Example_deleteDataset to delete a existing dataset.
Code:
datasetId := "REPLACE_WITH_DATASET_OCID"
client, err := datalabelingservice.NewDataLabelingManagementClientWithConfigurationProvider(common.DefaultConfigProvider())
if err != nil {
panic(err)
}
fmt.Println("Deleting dataset")
// deleteDatasetRequest create request for deletion of dataset
deleteDatasetRequest := datalabelingservice.DeleteDatasetRequest{
DatasetId: common.String(datasetId),
}
// Send the request using the service client
_, datasetErr := client.DeleteDataset(context.Background(), deleteDatasetRequest)
helpers.FatalIfError(datasetErr)
fmt.Println("Dataset deleted")
▹ Example (DeleteRecord)
▾ Example (DeleteRecord)
Code:
recordId := "REPLACE_WITH_RECORD_OCID"
client, err := datalabelingservicedataplane.NewDataLabelingClientWithConfigurationProvider(common.DefaultConfigProvider())
if err != nil {
panic(err)
}
fmt.Println("Deleting record.")
deleteRecordRequest := datalabelingservicedataplane.DeleteRecordRequest{
RecordId: common.String(recordId),
}
_, recordErr := client.DeleteRecord(context.Background(), deleteRecordRequest)
helpers.FatalIfError(recordErr)
fmt.Println("Record deletion succeeded.")
fmt.Println("Done")
Output:
Deleting record. Record deletion succeeded. Done
▹ Example (DnsSteeringPolicy)
▾ Example (DnsSteeringPolicy)
ExampleSteeringPolicy creates, gets, lists, and deletes a DNS Steering Policy. If optional TARGET_COMPARTMENT_ID env var is set, it will also move the DNS Steering Policy to the compartment.
Code:
client, err := dns.NewDnsClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(err) // Optional parsed value from env var TARGET_COMPARTMENT_ID targetCompartmentId := os.Getenv("TARGET_COMPARTMENT_ID") log.Printf("TARGET_COMPARTMENT_ID: %s", targetCompartmentId) ctx := context.Background() // Create a new steering policy displayName := common.String(helpers.GetRandomString(15)) createReq := dns.CreateSteeringPolicyRequest{ CreateSteeringPolicyDetails: dns.CreateSteeringPolicyDetails{ CompartmentId: helpers.CompartmentID(), DisplayName: displayName, Template: dns.CreateSteeringPolicyDetailsTemplateLoadBalance, Ttl: common.Int(60), }, } createResp, err := client.CreateSteeringPolicy(ctx, createReq) helpers.FatalIfError(err) fmt.Printf("created dns steering policy %s", *displayName) // below logic is to wait until steering policy is in active state pollUntilAvailable := func(r common.OCIOperationResponse) bool { if converted, ok := r.Response.(dns.GetSteeringPolicyResponse); ok { return converted.LifecycleState != dns.SteeringPolicyLifecycleStateActive } return true } getRequest := dns.GetSteeringPolicyRequest{ SteeringPolicyId: createResp.Id, RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(pollUntilAvailable), } getResp, err := client.GetSteeringPolicy(ctx, getRequest) helpers.FatalIfError(err) fmt.Printf("get dns steering policy %s", *displayName) listResp, err := client.ListSteeringPolicies(ctx, dns.ListSteeringPoliciesRequest{ CompartmentId: helpers.CompartmentID(), DisplayNameContains: displayName, Limit: common.Int64(10), SortBy: dns.ListSteeringPoliciesSortByTimecreated, SortOrder: dns.ListSteeringPoliciesSortOrderAsc, }) helpers.FatalIfError(err) fmt.Println("list dns steering policies") log.Printf("count of dns steering policies in compartment %s: %d", *helpers.CompartmentID(), listResp.OpcTotalItems) if targetCompartmentId != "" && targetCompartmentId != *helpers.CompartmentID() { changeRequest := dns.ChangeSteeringPolicyCompartmentRequest{ SteeringPolicyId: getResp.Id, ChangeSteeringPolicyCompartmentDetails: dns.ChangeSteeringPolicyCompartmentDetails{ CompartmentId: &targetCompartmentId, }, } _, err := client.ChangeSteeringPolicyCompartment(ctx, changeRequest) helpers.FatalIfError(err) fmt.Printf("change dns steering policy compartment to %s", targetCompartmentId) } // Clean up defer func() { _, err = client.DeleteSteeringPolicy(ctx, dns.DeleteSteeringPolicyRequest{ SteeringPolicyId: getResp.Id, }) helpers.FatalIfError(err) }()
Output:
created dns steering policy get dns steering policy list dns steering policy deleted dns steering policy
▹ Example (DnsZone)
▾ Example (DnsZone)
Example_dnsZone creates, gets, lists, and deletes a DNS Zone. If optional TARGET_COMPARTMENT_ID env var is set, it will also move the DNS Zone to the compartment.
Code:
client, err := dns.NewDnsClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(err) // Optional parsed value from env var TARGET_COMPARTMENT_ID targetCompartmentId := os.Getenv("TARGET_COMPARTMENT_ID") log.Printf("TARGET_COMPARTMENT_ID: %s", targetCompartmentId) ctx := context.Background() // Create a new zone zoneName := common.String("testdomain." + helpers.GetRandomString(15)) createReq := dns.CreateZoneRequest{ CreateZoneDetails: dns.CreateZoneDetails{ CompartmentId: helpers.CompartmentID(), Name: zoneName, ZoneType: dns.CreateZoneDetailsZoneTypePrimary, }, } createResp, err := client.CreateZone(ctx, createReq) helpers.FatalIfError(err) fmt.Printf("created dns zone %s", *zoneName) // below logic is to wait until zone is in active state pollUntilAvailable := func(r common.OCIOperationResponse) bool { if converted, ok := r.Response.(dns.GetZoneResponse); ok { return converted.LifecycleState != dns.ZoneLifecycleStateActive } return true } getRequest := dns.GetZoneRequest{ ZoneNameOrId: createResp.Id, CompartmentId: helpers.CompartmentID(), RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(pollUntilAvailable), } getResp, err := client.GetZone(ctx, getRequest) helpers.FatalIfError(err) fmt.Printf("get dns zone %s", *zoneName) listResp, err := client.ListZones(ctx, dns.ListZonesRequest{ CompartmentId: helpers.CompartmentID(), NameContains: zoneName, Limit: common.Int64(10), SortBy: dns.ListZonesSortByTimecreated, SortOrder: dns.ListZonesSortOrderAsc, }) helpers.FatalIfError(err) fmt.Println("list dns zones") log.Printf("count of dns zones in compartment %s: %d", *helpers.CompartmentID(), listResp.OpcTotalItems) if targetCompartmentId != "" && targetCompartmentId != *helpers.CompartmentID() { changeRequest := dns.ChangeZoneCompartmentRequest{ ZoneId: getResp.Id, ChangeZoneCompartmentDetails: dns.ChangeZoneCompartmentDetails{ CompartmentId: &targetCompartmentId, }, } _, err := client.ChangeZoneCompartment(ctx, changeRequest) helpers.FatalIfError(err) fmt.Printf("change dns zone compartment to %s", targetCompartmentId) } // Clean up defer func() { _, err = client.DeleteZone(ctx, dns.DeleteZoneRequest{ ZoneNameOrId: getResp.Id, }) helpers.FatalIfError(err) }()
Output:
created dns zone get dns zone list dns zone deleted dns zone
▹ Example (EmailSender)
▾ Example (EmailSender)
Code:
package example
import (
"context"
"fmt"
"log"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/email"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
)
const (
// The address of the email sender
senderEmailAddress = "sample@sample.com"
)
func Example_emailSender() {
client, err := email.NewEmailClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
ctx := context.Background()
createReq := email.CreateSenderRequest{
CreateSenderDetails: email.CreateSenderDetails{
CompartmentId: helpers.CompartmentID(),
EmailAddress: common.String(senderEmailAddress),
},
}
createResp, err := client.CreateSender(ctx, createReq)
helpers.FatalIfError(err)
fmt.Println("email sender created")
getReq := email.GetSenderRequest{
SenderId: createResp.Id,
}
getResp, err := client.GetSender(ctx, getReq)
helpers.FatalIfError(err)
fmt.Println("get email sender")
log.Printf("get email sender with email address %s\n", *getResp.EmailAddress)
// you can provide additional filters and sorts, here lists all senders
// sorted by email address and filter by email address
listReq := email.ListSendersRequest{
CompartmentId: helpers.CompartmentID(),
SortBy: email.ListSendersSortByEmailaddress,
SortOrder: email.ListSendersSortOrderAsc,
}
listResp, err := client.ListSenders(ctx, listReq)
helpers.FatalIfError(err)
log.Printf("list email senders return %v results\n", len(listResp.Items))
fmt.Println("list email senders")
defer func() {
deleteReq := email.DeleteSenderRequest{
SenderId: getReq.SenderId,
}
_, err = client.DeleteSender(ctx, deleteReq)
helpers.FatalIfError(err)
fmt.Println("email sender deleted")
}()
// Output:
// email sender created
// get email sender
// list email senders
// email sender deleted
}
▹ Example (FreeformAndDefinedTag)
▾ Example (FreeformAndDefinedTag)
Example_freeformAndDefinedTag shows how to use freeform and defined tags
Code:
// create a tag namespace and two tags identityClient, err := identity.NewIdentityClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(err) ctx := context.Background() tagNamespaceName := "GOSDKSampleTagNamespaceName_1" tagNamespaceID := createTagNamespace(ctx, identityClient, common.String(tagNamespaceName)) fmt.Println("tag namespace created") tagName := "GOSDKSampleTagName_1" createTag(ctx, identityClient, tagNamespaceID, common.String(tagName)) fmt.Println("tag1 created") tagName2 := "GOSDKSampleTagName_2" createTag(ctx, identityClient, tagNamespaceID, common.String(tagName2)) fmt.Println("tag2 created") // We can assign freeform and defined tags at resource creation time. Freeform tags are a dictionary of // string-to-string, where the key is the tag name and the value is the tag value. // // Defined tags are a dictionary where the key is the tag namespace (string) and the value is another dictionary. In // this second dictionary, the key is the tag name (string) and the value is the tag value. The tag names have to // correspond to the name of a tag within the specified namespace (and the namespace must exist). freeformTags := map[string]string{"free": "form", "another": "item"} definedTags := map[string]map[string]interface{}{ tagNamespaceName: { tagName: "hello", tagName2: "world", }, } coreClient, clerr := core.NewVirtualNetworkClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(clerr) // create a new VCN with tags createVCNReq := core.CreateVcnRequest{ CreateVcnDetails: core.CreateVcnDetails{ CidrBlock: common.String("10.0.0.0/16"), CompartmentId: helpers.CompartmentID(), DisplayName: common.String("GOSDKSampleVCNName"), DnsLabel: common.String("vcndns"), FreeformTags: freeformTags, DefinedTags: definedTags, }, } resp, err := coreClient.CreateVcn(ctx, createVCNReq) if err != nil && resp.RawResponse.StatusCode == 404 { // You may get a 404 if you create/reactivate a tag and try and use it straight away. If you have a delay/sleep between // creating the tag and then using it (or alternatively retry the 404) that may resolve the issue. time.Sleep(time.Second * 10) resp, err = coreClient.CreateVcn(ctx, createVCNReq) } helpers.FatalIfError(err) fmt.Println("VCN created with tags") // replace the tag freeformTags = map[string]string{"total": "replaced"} // update the tag value definedTags[tagNamespaceName][tagName2] = "replaced" // update the VCN with different tag values updateVCNReq := core.UpdateVcnRequest{ VcnId: resp.Id, UpdateVcnDetails: core.UpdateVcnDetails{ FreeformTags: freeformTags, DefinedTags: definedTags, }, } _, err = coreClient.UpdateVcn(ctx, updateVCNReq) helpers.FatalIfError(err) fmt.Println("VCN tag updated") // remove the tag from VCN updateVCNReq.FreeformTags = nil updateVCNReq.DefinedTags = nil _, err = coreClient.UpdateVcn(ctx, updateVCNReq) helpers.FatalIfError(err) fmt.Println("VCN tag removed") defer func() { request := core.DeleteVcnRequest{ VcnId: resp.Id, } _, err = coreClient.DeleteVcn(ctx, request) helpers.FatalIfError(err) fmt.Println("VCN deleted") }()
Output:
tag namespace created tag1 created tag2 created VCN created with tags VCN tag updated VCN tag removed VCN deleted
▹ Example (FunctionInvoke)
▾ Example (FunctionInvoke)
SETUP: This test requires that you have a [DEFAULT] OCI user profile setup e.g. in ~/.oci/config the DEFAULT user will be used in these tests, so any variables supplied must be compatible with that user This test requires 4 environment variables to be set: for these environment variables, see example/example_test.go { OCI_COMPARTMENT_ID OCI_AVAILABILITY_DOMAIN OCI_ROOT_COMPARTMENT_ID } OCI_FN_IMAGE : The URI of a publicly available image in the Oracle Cloud Infrastructure Registry (OCIR) e.g. phx.ocir.io/<tenancy-name>/<directory>/<image-name>:<image-tag> RUN: To run this test/example run: go test github.com/oracle/oci-go-sdk/example -run Example_functionInvoke
Code:
package example
import (
"bytes"
"context"
"fmt"
"io/ioutil"
"net/http"
"os"
"reflect"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/core"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
"github.com/oracle/oci-go-sdk/v65/functions"
)
var (
fnImage string
gwDisplayName = "OCI-GOSDK-Sample-Gateway"
rtDisplyName = "Default Route Table for OCI-GOSDK-Sample-VCN"
)
/*
SETUP:
This test requires that you have a [DEFAULT] OCI user profile setup e.g. in ~/.oci/config
the DEFAULT user will be used in these tests, so any variables supplied must be compatible with that user
This test requires 4 environment variables to be set:
for these environment variables, see example/example_test.go {
OCI_COMPARTMENT_ID
OCI_AVAILABILITY_DOMAIN
OCI_ROOT_COMPARTMENT_ID
}
OCI_FN_IMAGE : The URI of a publicly available image in the Oracle Cloud Infrastructure Registry (OCIR) e.g. phx.ocir.io/<tenancy-name>/<directory>/<image-name>:<image-tag>
RUN:
To run this test/example run:
go test github.com/oracle/oci-go-sdk/example -run Example_functionInvoke
*/
func Example_functionInvoke() {
managementClient, err := functions.NewFunctionsManagementClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
fnImage = os.Getenv("OCI_FN_IMAGE")
ctx := context.Background()
subnetID := createOrGetNetworkInfrastructure()
// A subnet is required to expose and be able invoke functions.
// In multiple AD regions, subnets can be created in multiple ADs to provide redundancy.
fmt.Println("Network Layer Created")
// An application's name must be unique per-compartment
appName := "Example-Go-SDK-App"
// A function's name must be unique per-application
fnName := "Example-Go-SDK-Fn"
// We must specify which compartment we want to create our Application in
compartmentID := helpers.CompartmentID()
createdApp := createApplication(ctx, managementClient, appName, compartmentID, []string{*subnetID})
fmt.Println("Application Created:", *createdApp.DisplayName)
gotApp := getReadyApplication(ctx, managementClient, createdApp.Id)
fmt.Println("Application Got:", *gotApp.DisplayName)
listedApps := listApplications(ctx, managementClient, compartmentID)
fmt.Println("Applications Listed:", *listedApps[0].DisplayName)
createdFn := createFunction(ctx, managementClient, fnName, createdApp.Id)
fmt.Println("Function Created:", *createdFn.DisplayName)
gotFn := getReadyFunction(ctx, managementClient, createdFn.Id)
fmt.Println("Function Got:", *gotFn.DisplayName)
listedFns := listFunctions(ctx, managementClient, createdApp.Id)
fmt.Println("Functions Listed:", *listedFns[0].DisplayName)
invokeClient, err := functions.NewFunctionsInvokeClientWithConfigurationProvider(common.DefaultConfigProvider(), *createdFn.InvokeEndpoint)
helpers.FatalIfError(err)
invokeFunction(ctx, invokeClient, createdFn.Id)
fmt.Println("Function invoked")
deleteFunction(ctx, managementClient, createdFn.Id)
fmt.Println("Function Deleted:", *createdFn.DisplayName)
deleteApplication(ctx, managementClient, createdApp.Id)
fmt.Println("Application Deleted:", *createdApp.DisplayName)
// Output:
// Network Layer Created
// Application Created: Example-Go-SDK-App
// Application Got: Example-Go-SDK-App
// Applications Listed: Example-Go-SDK-App
// Function Created: Example-Go-SDK-Fn
// Function Got: Example-Go-SDK-Fn
// Functions Listed: Example-Go-SDK-Fn
// Function invoked
// Function Deleted: Example-Go-SDK-Fn
// Application Deleted: Example-Go-SDK-App
}
func createApplication(ctx context.Context, client functions.FunctionsManagementClient, appName string, compartmentID *string, subnetIDs []string) functions.Application {
details := functions.CreateApplicationDetails{
CompartmentId: compartmentID,
DisplayName: &appName,
SubnetIds: subnetIDs,
}
request := functions.CreateApplicationRequest{CreateApplicationDetails: details}
response, err := client.CreateApplication(ctx, request)
helpers.FatalIfError(err)
return response.Application
}
// Gets an application, if that application is not ready polls until the application is ready
func getReadyApplication(ctx context.Context, client functions.FunctionsManagementClient, appID *string) (app functions.Application) {
metaWithRetry := helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryGetApplication)
request := functions.GetApplicationRequest{
ApplicationId: appID,
RequestMetadata: metaWithRetry,
}
response, err := client.GetApplication(ctx, request)
helpers.FatalIfError(err)
return response.Application
}
func listApplications(ctx context.Context, client functions.FunctionsManagementClient, compartmentID *string) []functions.ApplicationSummary {
request := functions.ListApplicationsRequest{CompartmentId: compartmentID}
response, err := client.ListApplications(ctx, request)
helpers.FatalIfError(err)
return response.Items
}
func deleteApplication(ctx context.Context, client functions.FunctionsManagementClient, appID *string) {
request := functions.DeleteApplicationRequest{ApplicationId: appID}
_, err := client.DeleteApplication(ctx, request)
helpers.FatalIfError(err)
return
}
func createFunction(ctx context.Context, client functions.FunctionsManagementClient, fnName string, appID *string) functions.Function {
memory := int64(128)
details := functions.CreateFunctionDetails{
DisplayName: &fnName,
ApplicationId: appID,
Image: &fnImage,
MemoryInMBs: &memory,
}
request := functions.CreateFunctionRequest{CreateFunctionDetails: details}
response, err := client.CreateFunction(ctx, request)
helpers.FatalIfError(err)
return response.Function
}
func getReadyFunction(ctx context.Context, client functions.FunctionsManagementClient, fnID *string) functions.Function {
metaWithRetry := helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryGetFunction)
request := functions.GetFunctionRequest{
FunctionId: fnID,
RequestMetadata: metaWithRetry,
}
response, err := client.GetFunction(ctx, request)
helpers.FatalIfError(err)
return response.Function
}
func listFunctions(ctx context.Context, client functions.FunctionsManagementClient, appID *string) []functions.FunctionSummary {
request := functions.ListFunctionsRequest{ApplicationId: appID}
response, err := client.ListFunctions(ctx, request)
helpers.FatalIfError(err)
return response.Items
}
func invokeFunction(ctx context.Context, client functions.FunctionsInvokeClient, fnID *string) *string {
// Retry function invocation with a standard back-off if we get a 404 in response.
// This is in case the function creation has not yet completed by the time invocation is attempted
metaWithRetry := helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryInvokeFunction)
requestBody := ioutil.NopCloser(bytes.NewReader([]byte("")))
request := functions.InvokeFunctionRequest{
FunctionId: fnID,
InvokeFunctionBody: requestBody,
RequestMetadata: metaWithRetry,
}
response, err := client.InvokeFunction(ctx, request)
if err != nil {
fmt.Println("Invoke Error:", err)
return nil
}
resp := response.RawResponse
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
fmt.Println("Invoke Failed:", resp.StatusCode)
return nil
}
bodyBytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("Could not read invoke body:", err)
}
responseBody := string(bodyBytes)
return &responseBody
}
func deleteFunction(ctx context.Context, client functions.FunctionsManagementClient, fnID *string) {
request := functions.DeleteFunctionRequest{FunctionId: fnID}
_, err := client.DeleteFunction(ctx, request)
helpers.FatalIfError(err)
return
}
func createOrGetNetworkInfrastructure() *string {
c, err := core.NewVirtualNetworkClientWithConfigurationProvider(common.DefaultConfigProvider())
if err != nil {
fmt.Println("Network client request error:", err)
}
sn := CreateOrGetSubnet()
gw := createOrGetInternetGateway(c, sn.VcnId)
createOrGetRouteTable(c, gw.Id, sn.VcnId)
return sn.Id
}
func createOrGetInternetGateway(c core.VirtualNetworkClient, vcnID *string) (gateway core.InternetGateway) {
ctx := context.Background()
//List Gateways
listGWRequest := core.ListInternetGatewaysRequest{
CompartmentId: helpers.CompartmentID(),
VcnId: vcnID,
DisplayName: &gwDisplayName,
}
listGWRespone, err := c.ListInternetGateways(ctx, listGWRequest)
if err != nil {
fmt.Println("Internet gateway list error:", err)
}
if len(listGWRespone.Items) >= 1 {
//Gateway with name already exists
gateway = listGWRespone.Items[0]
} else {
//Create new Gateway
enabled := true
createGWDetails := core.CreateInternetGatewayDetails{
CompartmentId: helpers.CompartmentID(),
IsEnabled: &enabled,
VcnId: vcnID,
DisplayName: &gwDisplayName,
}
createGWRequest := core.CreateInternetGatewayRequest{CreateInternetGatewayDetails: createGWDetails}
createGWResponse, err := c.CreateInternetGateway(ctx, createGWRequest)
if err != nil {
fmt.Println("Internet gateway create error:", err)
}
gateway = createGWResponse.InternetGateway
}
return
}
func createOrGetRouteTable(c core.VirtualNetworkClient, gatewayID, VcnID *string) (routeTable core.RouteTable) {
ctx := context.Background()
//List Route Table
listRTRequest := core.ListRouteTablesRequest{
CompartmentId: helpers.CompartmentID(),
VcnId: VcnID,
DisplayName: &rtDisplyName,
}
listRTResponse, err := c.ListRouteTables(ctx, listRTRequest)
if err != nil {
fmt.Println("Route table list error", err)
}
cidrRange := "0.0.0.0/0"
rr := core.RouteRule{
NetworkEntityId: gatewayID,
Destination: &cidrRange,
DestinationType: core.RouteRuleDestinationTypeCidrBlock,
}
if len(listRTResponse.Items) >= 1 {
//Default Route Table found and has at least 1 route rule
if len(listRTResponse.Items[0].RouteRules) >= 1 {
routeTable = listRTResponse.Items[0]
//Default Route table needs route rule adding
} else {
updateRTDetails := core.UpdateRouteTableDetails{
RouteRules: []core.RouteRule{rr},
}
updateRTRequest := core.UpdateRouteTableRequest{
RtId: listRTResponse.Items[0].Id,
UpdateRouteTableDetails: updateRTDetails,
}
updateRTResponse, err := c.UpdateRouteTable(ctx, updateRTRequest)
if err != nil {
fmt.Println("Error updating route table:", err)
}
routeTable = updateRTResponse.RouteTable
}
} else {
//No default route table found
fmt.Println("Error could not find VCN default route table, VCN OCID:", *VcnID, "Could not find route table:", rtDisplyName)
}
return
}
func shouldRetryGetApplication(response common.OCIOperationResponse) bool {
createResponse, correctType := response.Response.(functions.GetApplicationResponse)
if !correctType {
fmt.Println("Retry attempt used incompatible response type, expected GetApplicationResponse, found:", reflect.TypeOf(response.Response))
}
if createResponse.LifecycleState != functions.ApplicationLifecycleStateActive {
return true
}
return false
}
func shouldRetryGetFunction(response common.OCIOperationResponse) bool {
createResponse, correctType := response.Response.(functions.GetFunctionResponse)
if !correctType {
fmt.Println("Retry attempt used incompatible response type, expected GetFunctionResponse, found:", reflect.TypeOf(response.Response))
}
if createResponse.LifecycleState != functions.FunctionLifecycleStateActive {
return true
}
return false
}
func shouldRetryInvokeFunction(response common.OCIOperationResponse) bool {
invokeResponse, correctType := response.Response.(functions.InvokeFunctionResponse)
if !correctType {
fmt.Println("Retry attempt used incompatible response type, expected InvokeFunctionResponse, found:", reflect.TypeOf(response.Response))
}
if invokeResponse.RawResponse.StatusCode == 404 {
return true
}
return false
}
▹ Example (GetBackupDestination)
▾ Example (GetBackupDestination)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
getbackupDestinationReq := database.GetBackupDestinationRequest{
BackupDestinationId: common.String("backup-destination-ocid"),
}
_, err := c.GetBackupDestination(context.Background(), getbackupDestinationReq)
helpers.FatalIfError(err)
fmt.Println("get backup destination is successful")
Output:
get backup destination is successful
▹ Example (GetDataset)
▾ Example (GetDataset)
Example_getDataset to get dataset details from a given dataset Id.
Code:
datasetId := "REPLACE_WITH_DATASET_OCID"
client, err := datalabelingservice.NewDataLabelingManagementClientWithConfigurationProvider(common.DefaultConfigProvider())
if err != nil {
panic(err)
}
fmt.Println("Getting dataset")
getDatasetRequest := datalabelingservice.GetDatasetRequest{
DatasetId: common.String(datasetId),
}
// Send the request using the service client
_, datasetErr := client.GetDataset(context.Background(), getDatasetRequest)
helpers.FatalIfError(datasetErr)
fmt.Println("Done.")
▹ Example (GetRecords)
▾ Example (GetRecords)
Code:
recordId := "REPLACE_WITH_RECORD_OCID"
client, err := datalabelingservicedataplane.NewDataLabelingClientWithConfigurationProvider(common.DefaultConfigProvider())
if err != nil {
panic(err)
}
fmt.Println("Getting record.")
// getRecordRequest creating a request body
getRecordRequest := datalabelingservicedataplane.GetRecordRequest{
RecordId: common.String(recordId),
OpcRequestId: nil,
RequestMetadata: common.RequestMetadata{},
}
// Send the request using the service client
_, recordErr := client.GetRecord(context.Background(), getRecordRequest)
helpers.FatalIfError(recordErr)
fmt.Println("Get record succeeded.")
fmt.Println("Done")
Output:
Getting record. Get record succeeded. Done
▹ Example (HealthChecksHttpSamples)
▾ Example (HealthChecksHttpSamples)
Code:
ctx := context.Background() // Initialize default config provider configProvider := common.DefaultConfigProvider() if ok, err := common.IsConfigurationProviderValid(configProvider); !ok { panic(err) } client, clerr := healthchecks.NewHealthChecksClientWithConfigurationProvider(configProvider) helpers.FatalIfError(clerr) compartmentId, _ := configProvider.TenancyOCID() _ = exampleListVantagePoints(ctx, client) //fmt.Println(vantagePoints) fmt.Println("List Vantage Points") httpMonitor := exampleCreateHttpMonitor(ctx, client, &compartmentId) fmt.Println("Create Monitor") httpMonitor = exampleUpdateHttpMonitor(ctx, client, httpMonitor.Id) fmt.Println("Update Monitor") //fmt.Println(httpMonitor) _ = exampleListHttpMonitorResults(ctx, client, httpMonitor.Id) fmt.Println("Retrieved Results") // We need a different compartment to run this. // exampleMoveCompartmentHttpMonitor(ctx, client, httpMonitor.Id, &compartmentId) exampleDeleteHttpMonitor(ctx, client, httpMonitor.Id) fmt.Println("Deleted Monitor")
Output:
List Vantage Points Create Monitor Update Monitor Retrieved Results Deleted Monitor
▹ Example (HealthChecksPingSamples)
▾ Example (HealthChecksPingSamples)
Code:
ctx := context.Background() // Initialize default config provider configProvider := common.DefaultConfigProvider() if ok, err := common.IsConfigurationProviderValid(configProvider); !ok { panic(err) } client, clerr := healthchecks.NewHealthChecksClientWithConfigurationProvider(configProvider) helpers.FatalIfError(clerr) compartmentId, _ := configProvider.TenancyOCID() _ = exampleListVantagePoints(ctx, client) //fmt.Println(vantagePoints) fmt.Println("List Vantage Points") pingMonitor := exampleCreatePingMonitor(ctx, client, &compartmentId) fmt.Println("Create Monitor") pingMonitor = exampleUpdatePingMonitor(ctx, client, pingMonitor.Id) fmt.Println("Update Monitor") //fmt.Println(pingMonitor) _ = exampleListPingMonitorResults(ctx, client, pingMonitor.Id) fmt.Println("Retrieved Results") // We need a different compartment to run this. // exampleMoveCompartmentPingMonitor(ctx, client, pingMonitor.Id, &compartmentId) exampleDeletePingMonitor(ctx, client, pingMonitor.Id) fmt.Println("Deleted Monitor")
Output:
List Vantage Points Create Monitor Update Monitor Retrieved Results Deleted Monitor
▹ Example (InstancePrincipals)
▾ Example (InstancePrincipals)
Code:
provider, err := auth.InstancePrincipalConfigurationProvider()
helpers.FatalIfError(err)
tenancyID := helpers.RootCompartmentID()
request := identity.ListAvailabilityDomainsRequest{
CompartmentId: tenancyID,
}
client, err := identity.NewIdentityClientWithConfigurationProvider(provider)
// Override the region, this is an optional step.
// the InstancePrincipalsConfigurationProvider defaults to the region
// in which the compute instance is currently running
client.SetRegion(string(common.RegionLHR))
r, err := client.ListAvailabilityDomains(context.Background(), request)
helpers.FatalIfError(err)
log.Printf("list of available domains: %v", r.Items)
fmt.Println("Done")
Output:
Done
▹ Example (InstancePrincipalsWithCustomClient)
▾ Example (InstancePrincipalsWithCustomClient)
Example_instancePrincipalsWithCustomClient lists the availability domains in your tenancy. Similar to the example above, this example shows how to customize the client.
Code:
// Just load the system cert pool for demonstration purposes.
rootCaPool, err := x509.SystemCertPool()
helpers.FatalIfError(err)
provider, err := auth.InstancePrincipalConfigurationProviderWithCustomClient(func(dispatcher common.HTTPRequestDispatcher) (common.HTTPRequestDispatcher, error) {
client := dispatcher.(*http.Client)
client.Transport = &http.Transport{
TLSClientConfig: &tls.Config{
RootCAs: rootCaPool,
},
}
return client, nil
})
tenancyID := helpers.RootCompartmentID()
request := identity.ListAvailabilityDomainsRequest{
CompartmentId: tenancyID,
}
client, err := identity.NewIdentityClientWithConfigurationProvider(provider)
r, err := client.ListAvailabilityDomains(context.Background(), request)
helpers.FatalIfError(err)
log.Printf("list of available domains: %v", r.Items)
fmt.Println("Done")
▹ Example (KeyOperations)
▾ Example (KeyOperations)
ExampleKeyManagement_KeyOperations shows how to create, enable and disable a KMS key
Code:
vaultClient, clientError := keymanagement.NewKmsVaultClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(clientError) ctx := context.Background() vaultName := "KmsVault" keyName := "KmsKey" updatedKeyName := "UpdatedKmsKey" vault := createVault(ctx, vaultClient, vaultName) defer cleanupResources(ctx, vaultClient, vault.Id) // wait for instance lifecycle state becomes active waitForStateVaultClient(ctx, vault.Id, vaultClient, keymanagement.VaultLifecycleStateActive) vaultManagementClient, mgmtClientError := keymanagement. NewKmsManagementClientWithConfigurationProvider(common.DefaultConfigProvider(), *vault.ManagementEndpoint) helpers.FatalIfError(mgmtClientError) // Create Key key, _ := createKey(ctx, vaultManagementClient, &keyName) // Disable Key disableRequest := keymanagement.DisableKeyRequest{ KeyId: key.Id, } disableResponse, disableErr := vaultManagementClient.DisableKey(ctx, disableRequest) helpers.FatalIfError(disableErr) key = disableResponse.Key // Wait for key to be in Disabled state waitForStateVaultManagementClient(ctx, key.Id, vaultManagementClient, keymanagement.KeyLifecycleStateDisabled) fmt.Println("disable key") // Enable Key enableRequest := keymanagement.EnableKeyRequest{ KeyId: key.Id, } enableResponse, enableErr := vaultManagementClient.EnableKey(ctx, enableRequest) helpers.FatalIfError(enableErr) key = enableResponse.Key // Wait for key to be in Enabled state waitForStateVaultManagementClient(ctx, key.Id, vaultManagementClient, keymanagement.KeyLifecycleStateEnabled) fmt.Println("enable key") // Schedule Key Deletion scheduleKeyDeletionRequest := keymanagement.ScheduleKeyDeletionRequest{ KeyId: key.Id, } scheduleKeyDeletionResponse, scheduleKeyDeletionErr := vaultManagementClient.ScheduleKeyDeletion(ctx, scheduleKeyDeletionRequest) helpers.FatalIfError(scheduleKeyDeletionErr) key = scheduleKeyDeletionResponse.Key // Wait for key to be in PendingDeletion state waitForStateVaultManagementClient(ctx, key.Id, vaultManagementClient, keymanagement.KeyLifecycleStatePendingDeletion) fmt.Println("schedule key deletion") // Cancel Key Deletion cancelKeyDeletionRequest := keymanagement.CancelKeyDeletionRequest{ KeyId: key.Id, } cancelKeyDeletionResponse, cancelKeyDeletionErr := vaultManagementClient.CancelKeyDeletion(ctx, cancelKeyDeletionRequest) helpers.FatalIfError(cancelKeyDeletionErr) key = cancelKeyDeletionResponse.Key // Wait for key to be in Enabled state waitForStateVaultManagementClient(ctx, key.Id, vaultManagementClient, keymanagement.KeyLifecycleStateEnabled) fmt.Println("cancel scheduled key deletion") // Update Key updateKeyDetails := keymanagement.UpdateKeyDetails{ DisplayName: &updatedKeyName, } updateKeyRequest := keymanagement.UpdateKeyRequest{ KeyId: key.Id, UpdateKeyDetails: updateKeyDetails, } updateResponse, updateErr := vaultManagementClient.UpdateKey(ctx, updateKeyRequest) helpers.FatalIfError(updateErr) key = updateResponse.Key fmt.Println("update key") // Move to root compartment changeKeyCompartment(ctx, vaultManagementClient, helpers.RootCompartmentID(), key.Id) waitForStateVaultManagementClient(ctx, key.Id, vaultManagementClient, keymanagement.KeyLifecycleStateEnabled)
Output:
create vault create key disable key enable key schedule key deletion cancel scheduled key deletion update key change key compartment schedule vault deletion
▹ Example (KubeConfig)
▾ Example (KubeConfig)
Code:
ctx := context.Background()
c, clerr := containerengine.NewContainerEngineClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
clusterID := common.String("[YOUR CLUSTER ID]")
req := containerengine.CreateKubeconfigRequest{
ClusterId: clusterID,
}
_, err := c.CreateKubeconfig(ctx, req)
helpers.FatalIfError(err)
fmt.Println("create kubeconfig")
Output:
create kubeconfig
▹ Example (LaunchInstance)
▾ Example (LaunchInstance)
Example_launchInstance does create an instance NOTE: launch instance will create a new instance and VCN. please make sure delete the instance after execute this sample code, otherwise, you will be charged for the running instance
Code:
c, err := core.NewComputeClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(err) ctx := context.Background() // create the launch instance request request := core.LaunchInstanceRequest{} request.CompartmentId = helpers.CompartmentID() request.DisplayName = common.String("OCI-Sample-Instance") request.AvailabilityDomain = helpers.AvailabilityDomain() // create a subnet or get the one already created subnet := CreateOrGetSubnet() fmt.Println("subnet created") request.CreateVnicDetails = &core.CreateVnicDetails{SubnetId: subnet.Id} // get a image image := listImages(ctx, c)[0] fmt.Println("list images") request.SourceDetails = core.InstanceSourceViaImageDetails{ImageId: image.Id} // use VM.Standard2.1 to create instance request.Shape = common.String(instanceShape) // default retry policy will retry on non-200 response request.RequestMetadata = helpers.GetRequestMetadataWithDefaultRetryPolicy() createResp, err := c.LaunchInstance(ctx, request) helpers.FatalIfError(err) fmt.Println("launching instance") // should retry condition check which returns a bool value indicating whether to do retry or not // it checks the lifecycle status equals to Running or not for this case shouldRetryFunc := func(r common.OCIOperationResponse) bool { if converted, ok := r.Response.(core.GetInstanceResponse); ok { return converted.LifecycleState != core.InstanceLifecycleStateRunning } return true } // create get instance request with a retry policy which takes a function // to determine shouldRetry or not pollingGetRequest := core.GetInstanceRequest{ InstanceId: createResp.Instance.Id, RequestMetadata: helpers.GetRequestMetadataWithCustomizedRetryPolicy(shouldRetryFunc), } instance, pollError := c.GetInstance(ctx, pollingGetRequest) helpers.FatalIfError(pollError) fmt.Println("instance launched") attachVnicResponse, err := c.AttachVnic(context.Background(), core.AttachVnicRequest{ AttachVnicDetails: core.AttachVnicDetails{ CreateVnicDetails: &core.CreateVnicDetails{ SubnetId: subnet.Id, AssignPublicIp: common.Bool(true), }, InstanceId: instance.Id, }, }) helpers.FatalIfError(err) fmt.Println("vnic attached") vnicState := attachVnicResponse.VnicAttachment.LifecycleState for vnicState != core.VnicAttachmentLifecycleStateAttached { time.Sleep(15 * time.Second) getVnicAttachmentRequest, err := c.GetVnicAttachment(context.Background(), core.GetVnicAttachmentRequest{ VnicAttachmentId: attachVnicResponse.Id, }) helpers.FatalIfError(err) vnicState = getVnicAttachmentRequest.VnicAttachment.LifecycleState } _, err = c.DetachVnic(context.Background(), core.DetachVnicRequest{ VnicAttachmentId: attachVnicResponse.Id, }) helpers.FatalIfError(err) fmt.Println("vnic dettached") defer func() { terminateInstance(ctx, c, createResp.Id) client, clerr := core.NewVirtualNetworkClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(clerr) vcnID := subnet.VcnId deleteSubnet(ctx, client, subnet.Id) deleteVcn(ctx, client, vcnID) }()
Output:
subnet created list images list shapes launching instance instance launched vnic attached vnic dettached terminating instance instance terminated deleteing subnet subnet deleted deleteing VCN VCN deleted
▹ Example (ListAvailabilityDomains)
▾ Example (ListAvailabilityDomains)
Example_listAvailabilityDomains Lists the Availability Domains in your tenancy. Specify the OCID of either the tenancy or another of your compartments as the value for the compartment ID (remember that the tenancy is simply the root compartment).
Code:
c, err := identity.NewIdentityClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
// The OCID of the tenancy containing the compartment.
tenancyID, err := common.DefaultConfigProvider().TenancyOCID()
helpers.FatalIfError(err)
request := identity.ListAvailabilityDomainsRequest{
CompartmentId: &tenancyID,
}
r, err := c.ListAvailabilityDomains(context.Background(), request)
helpers.FatalIfError(err)
log.Printf("list of available domains: %v", r.Items)
fmt.Println("list available domains completed")
Output:
list available domains completed
▹ Example (ListDataset)
▾ Example (ListDataset)
Example_listDataset is to list all dataset in a given compartment Id.
Code:
compartment := "REPLACE_WITH_COMPARTMENT_OCID"
client, err := datalabelingservice.NewDataLabelingManagementClientWithConfigurationProvider(common.DefaultConfigProvider())
if err != nil {
panic(err)
}
fmt.Println("Listing all datasets")
req := datalabelingservice.ListDatasetsRequest{
CompartmentId: common.String(compartment),
Limit: common.Int(500),
LifecycleState: datalabelingservice.DatasetLifecycleStateActive,
}
// Send the request using the service client
_, datasetErr := client.ListDatasets(context.Background(), req)
helpers.FatalIfError(datasetErr)
fmt.Println("Listing datasets completed")
▹ Example (ListEvents)
▾ Example (ListEvents)
Code:
c, clerr := audit.NewAuditClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(clerr) // list events for last 5 hour req := audit.ListEventsRequest{ CompartmentId: helpers.CompartmentID(), StartTime: &common.SDKTime{time.Now().Add(time.Hour * -5)}, EndTime: &common.SDKTime{time.Now()}, } _, err := c.ListEvents(context.Background(), req) helpers.FatalIfError(err) //log.Printf("events returned back: %v", resp.Items) fmt.Println("list events completed")
Output:
list events completed
▹ Example (ListGroupsWithCustomSignedHeader)
▾ Example (ListGroupsWithCustomSignedHeader)
Example_listGroupsWithCustomSignedHeader Lists groups by passing a custom signed header in the request
Code:
provider := common.DefaultConfigProvider() c, err := identity.NewIdentityClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(err) //Bear in mind that services expect well known headers to be signed. Signing arbitrary headers //might lead to authentication errors customHeader := "opc-my-token" allHeaders := append(common.DefaultGenericHeaders(), customHeader) c.Signer = common.RequestSigner(provider, allHeaders, common.DefaultBodyHeaders()) c.Interceptor = func(request *http.Request) error { request.Header.Add(customHeader, "customvalue") return nil } // The OCID of the tenancy containing the compartment. tenancyID, _ := provider.TenancyOCID() request := identity.ListGroupsRequest{ CompartmentId: common.String(tenancyID), } r, err := c.ListGroups(context.Background(), request) helpers.FatalIfError(err) log.Printf("list groups completed: %v", r.Items) fmt.Println("list groups completed")
Output:
list groups completed
▹ Example (ListRecords)
▾ Example (ListRecords)
Code:
datasetId := "REPLACE_WITH_DATASET_OCID"
compartment := "REPLACE_WITH_COMPARTMENT_OCID"
client, err := datalabelingservicedataplane.NewDataLabelingClientWithConfigurationProvider(common.DefaultConfigProvider())
if err != nil {
panic(err)
}
fmt.Println("Listing records.")
listRecordsRequest := datalabelingservicedataplane.ListRecordsRequest{
CompartmentId: common.String(compartment),
DatasetId: common.String(datasetId),
Limit: common.Int(500),
SortBy: datalabelingservicedataplane.ListRecordsSortByTimecreated,
SortOrder: datalabelingservicedataplane.ListRecordsSortOrderDesc,
}
// Send the request using the service client
_, recordErr := client.ListRecords(context.Background(), listRecordsRequest)
helpers.FatalIfError(recordErr)
fmt.Println("Record listing succeeded.")
fmt.Println("Done")
Output:
Listing records. Record listing succeeded. Done
▹ Example (MoveCompartment)
▾ Example (MoveCompartment)
Example_moveCompartment Moves an active compartment under a different parent
Code:
package example
import (
"context"
"fmt"
"log"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
"github.com/oracle/oci-go-sdk/v65/identity"
)
// Example_moveCompartment Moves an active compartment under a different parent
func Example_moveCompartment() {
c, err := identity.NewIdentityClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
// The OCID of the tenancy containing the compartment.
tenancyID, err := common.DefaultConfigProvider().TenancyOCID()
helpers.FatalIfError(err)
ctx := context.Background()
cpSource := createCompartment(ctx, c, common.String(tenancyID), common.String("cp_source_GOSDK"))
cpTarget := createCompartment(ctx, c, common.String(tenancyID), common.String("cp_target_GOSDK"))
moveDetail := identity.MoveCompartmentDetails{
TargetCompartmentId: cpTarget,
}
moveRequest := identity.MoveCompartmentRequest{
CompartmentId: cpSource,
MoveCompartmentDetails: moveDetail,
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
resp, err := c.MoveCompartment(ctx, moveRequest)
helpers.FatalIfError(err)
log.Printf("move compartment with workrequest id: %s", *resp.OpcWorkRequestId)
fmt.Println("move compartment request is accepted")
// get cpSource new parent
cpSourceNewParent := getCompartment(ctx, c, cpSource).CompartmentId
cpSourceNewParentName := getCompartment(ctx, c, cpSourceNewParent).Name
log.Printf("cp_source_GOSDK new parent is: %v", *cpSourceNewParentName)
fmt.Println("move compartment completed")
// Output:
// move compartment request is accepted
// move compartment completed
}
func createCompartment(ctx context.Context, client identity.IdentityClient, tenantId *string, compartmentName *string) *string {
detail := identity.CreateCompartmentDetails{
CompartmentId: tenantId,
Name: compartmentName,
Description: compartmentName,
}
request := identity.CreateCompartmentRequest{
CreateCompartmentDetails: detail,
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
resp, err := client.CreateCompartment(ctx, request)
helpers.FatalIfError(err)
return resp.Id
}
func getCompartment(ctx context.Context, client identity.IdentityClient, compartmentId *string) identity.Compartment {
request := identity.GetCompartmentRequest{
CompartmentId: compartmentId,
RequestMetadata: helpers.GetRequestMetadataWithDefaultRetryPolicy(),
}
resp, err := client.GetCompartment(ctx, request)
helpers.FatalIfError(err)
return resp.Compartment
}
▹ Example (MultipartDownload)
▾ Example (MultipartDownload)
Example_multipartDownload shows how to use get object API to perform multi-part download operation
Code:
package example
import (
"context"
"fmt"
"io/ioutil"
"math"
"strconv"
"sync"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
"github.com/oracle/oci-go-sdk/v65/objectstorage"
)
// Example_multipartDownload shows how to use get object API to perform multi-part download operation
func Example_multipartDownload() {
c, err := objectstorage.NewObjectStorageClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
ctx := context.Background()
// Change the bname and objectName to the file name and bucket you want you download from
bname := "test_bucket_name"
objectName := "test_download_file"
// This value controls the size per part
partSize := 500
namespace := getNamespace(ctx, c)
downloadThread := 5
// Get the object size info from object storage
listResponse, err := c.ListObjects(ctx, objectstorage.ListObjectsRequest{
NamespaceName: common.String(namespace),
BucketName: common.String(bname),
Prefix: common.String(objectName),
Fields: common.String("name,size"),
})
helpers.FatalIfError(err)
// The result will return a list of objects with the required name, we just select the first in this example
size := int(*listResponse.Objects[0].Size)
totalParts := size / partSize
if size%partSize != 0 {
totalParts++
}
done := make(chan struct{})
prepareDownloadParts := splitToParts(done, totalParts, partSize, size, namespace, bname, objectName)
downloadedParts := multipartDownload(ctx, c, downloadThread, done, prepareDownloadParts)
// In this example, we're storing the download content in memory, please be aware of any issue with oom
result := make([]byte, size)
for part := range downloadedParts {
if part.err != nil {
// User should properly handle failure here, can be either raise an fatal error or retry to download the error part
// For this example, we simply ignore the error handling here
continue
}
for i := int64(0); i < part.size; i++ {
result[i+part.offset] = part.partBody[i]
}
}
fmt.Println(result)
}
// downloadPart contains the data downloaded from object storage and the body part info
type downloadPart struct {
size int64
partBody []byte
offset int64
partNum int
err error
}
// prepareDownloadPart wraps an GetObjectRequest with splitted part related info
type prepareDownloadPart struct {
request objectstorage.GetObjectRequest
offset int64
partNum int
size int64
}
// splitToParts splits the file to the partSize and build a new struct to prepare for multipart download, this function will return a prepareDownloadPart channel
func splitToParts(done <-chan struct{}, totalParts int, partSize int, fileSize int, namespace string, bname string, objectName string) chan prepareDownloadPart {
prepareDownloadParts := make(chan prepareDownloadPart)
go func() {
defer func() {
fmt.Println("Split to parts completed, closing channel")
close(prepareDownloadParts)
}()
for part := 0; part < totalParts; part++ {
start := int64(part * partSize)
end := int64(math.Min(float64((part+1)*partSize), float64(fileSize)) - 1)
bytesRange := strconv.FormatInt(start, 10) + "-" + strconv.FormatInt(end, 10)
part := prepareDownloadPart{
request: objectstorage.GetObjectRequest{
NamespaceName: common.String(namespace),
BucketName: common.String(bname),
ObjectName: common.String(objectName),
// This is the parameter where you control the download size/request
Range: common.String("bytes=" + bytesRange),
},
offset: start,
partNum: part,
size: end - start,
}
select {
case prepareDownloadParts <- part:
case <-done:
return
}
}
}()
return prepareDownloadParts
}
// multipartDownload will consume prepareDownloadPart from channel and from different gorountine, it will perform multipart download and save the download result to another channel
func multipartDownload(ctx context.Context, c objectstorage.ObjectStorageClient, downloadThreads int, done <-chan struct{}, prepareDownloadParts chan prepareDownloadPart) chan downloadPart {
result := make(chan downloadPart)
var wg sync.WaitGroup
wg.Add(downloadThreads)
for i := 0; i < downloadThreads; i++ {
go func() {
downloadFilePart(ctx, c, done, prepareDownloadParts, result)
wg.Done()
}()
}
go func() {
wg.Wait()
close(result)
}()
return result
}
// downloadFilePart wraps objectStorage GetObject API call
func downloadFilePart(ctx context.Context, c objectstorage.ObjectStorageClient, done <-chan struct{}, prepareDownloadParts chan prepareDownloadPart, result chan downloadPart) {
for part := range prepareDownloadParts {
resp, err := c.GetObject(ctx, part.request)
downloadedPart := downloadPart{}
if err != nil {
fmt.Println("Error in downloading: ", err)
downloadedPart.err = err
} else {
content, _ := ioutil.ReadAll(resp.Content)
downloadedPart = downloadPart{
size: int64(len(content)),
partBody: content,
offset: part.offset,
partNum: part.partNum,
}
}
select {
case result <- downloadedPart:
case <-done:
fmt.Println("downloadParts received Done")
return
}
}
}
▹ Example (NodePoolCRUD)
▾ Example (NodePoolCRUD)
Example for NodePool
Code:
ctx := context.Background()
c, clerr := containerengine.NewContainerEngineClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
compute, err := core.NewComputeClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
identityClient, err := identity.NewIdentityClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
req := identity.ListAvailabilityDomainsRequest{}
req.CompartmentId = helpers.CompartmentID()
ads, err := identityClient.ListAvailabilityDomains(ctx, req)
helpers.FatalIfError(err)
// create network resources for cluster
vcnID, subnet1ID, subnet2ID := createVCNWithSubnets(ctx)
// create cluster
kubeVersion := getDefaultKubernetesVersion(c)
createClusterResp := createCluster(ctx, c, vcnID, kubeVersion, subnet1ID)
// wait until work request complete
workReqResp := waitUntilWorkRequestComplete(c, createClusterResp.OpcWorkRequestId)
fmt.Println("cluster created")
clusterID := getResourceID(workReqResp.Resources, containerengine.WorkRequestResourceActionTypeCreated, "CLUSTER")
// get Image Id
image := getImageID(ctx, compute)
// create NodePool
createNodePoolReq := containerengine.CreateNodePoolRequest{}
createNodePoolReq.CompartmentId = helpers.CompartmentID()
createNodePoolReq.Name = common.String("GOSDK_SAMPLE_NP")
createNodePoolReq.ClusterId = clusterID
createNodePoolReq.KubernetesVersion = common.String(kubeVersion)
createNodePoolReq.NodeSourceDetails = containerengine.NodeSourceViaImageDetails{ImageId: image.Id}
createNodePoolReq.NodeShape = common.String("VM.Standard1.1")
createNodePoolReq.InitialNodeLabels = []containerengine.KeyValue{{Key: common.String("foo"), Value: common.String("bar")}}
createNodePoolReq.NodeConfigDetails = &containerengine.CreateNodePoolNodeConfigDetails{
PlacementConfigs: make([]containerengine.NodePoolPlacementConfigDetails, 0, len(ads.Items)),
Size: common.Int(len(ads.Items)),
}
for i := 0; i < len(ads.Items); i++ {
createNodePoolReq.NodeConfigDetails.PlacementConfigs = append(createNodePoolReq.NodeConfigDetails.PlacementConfigs,
containerengine.NodePoolPlacementConfigDetails{
AvailabilityDomain: ads.Items[i].Name,
SubnetId: &subnet2ID,
})
}
createNodePoolResp, err := c.CreateNodePool(ctx, createNodePoolReq)
helpers.FatalIfError(err)
fmt.Println("creating nodepool")
workReqResp = waitUntilWorkRequestComplete(c, createNodePoolResp.OpcWorkRequestId)
fmt.Println("nodepool created")
nodePoolID := getResourceID(workReqResp.Resources, containerengine.WorkRequestResourceActionTypeCreated, "NODEPOOL")
defer func() {
deleteNodePool(ctx, c, nodePoolID)
deleteCluster(ctx, c, clusterID)
}()
// update NodePool
updateNodePoolReq := containerengine.UpdateNodePoolRequest{
NodePoolId: nodePoolID,
}
updateNodePoolReq.Name = common.String("GOSDK_SAMPLE_NP_NEW")
updateNodePoolResp, err := c.UpdateNodePool(ctx, updateNodePoolReq)
helpers.FatalIfError(err)
fmt.Println("updating nodepool")
workReqResp = waitUntilWorkRequestComplete(c, updateNodePoolResp.OpcWorkRequestId)
fmt.Println("nodepool updated")
Output:
create VCN complete create subnet1 complete create subnet2 complete creating cluster cluster created creating nodepool nodepool created updating nodepool nodepool updated deleting nodepool deleting cluster
▹ Example (Quotas)
▾ Example (Quotas)
Example_quotas runs an example demonstrating the use of OCI Golang SDK for managing Quotas
Code:
package example // Import necessary packages import ( "context" // To supply to the Quotas client while making requests "fmt" // To print to the console "github.com/oracle/oci-go-sdk/v65/common" // For common OCI types "github.com/oracle/oci-go-sdk/v65/limits" // For types and methods corresponding to Limits ) // Creates a new Quota with the details given in createQuotaDetails func createQuota(client limits.QuotasClient, createQuotaDetails limits.CreateQuotaDetails) limits.CreateQuotaResponse { var response limits.CreateQuotaResponse response, err := client.CreateQuota(context.Background(), limits.CreateQuotaRequest{CreateQuotaDetails: createQuotaDetails}) if err != nil { panic(err) } return response } // Gets the Quota corresponding to given quotaId func getQuota(client limits.QuotasClient, quotaId string) limits.GetQuotaResponse { var response limits.GetQuotaResponse quotaIdStr := common.String(quotaId) response, err := client.GetQuota(context.Background(), limits.GetQuotaRequest{QuotaId: quotaIdStr}) if err != nil { panic(err) } return response } // Lists Quotas under the Compartment corresponding to given compartmentId func listQuotas(client limits.QuotasClient, compartmentId string) limits.ListQuotasResponse { var response limits.ListQuotasResponse compartmentIdStr := common.String(compartmentId) response, err := client.ListQuotas(context.Background(), limits.ListQuotasRequest{CompartmentId: compartmentIdStr}) if err != nil { panic(err) } return response } // Updates the Quota corresponding to given quotaId with values given in updateQuotaDetails func updateQuota(client limits.QuotasClient, quotaId string, updateQuotaDetails limits.UpdateQuotaDetails) limits.UpdateQuotaResponse { var response limits.UpdateQuotaResponse quotaIdStr := common.String(quotaId) response, err := client.UpdateQuota(context.Background(), limits.UpdateQuotaRequest{QuotaId: quotaIdStr, UpdateQuotaDetails: updateQuotaDetails}) if err != nil { panic(err) } return response } // Deletes the Quota corresponding to given quotaId func deleteQuota(client limits.QuotasClient, quotaId string) limits.DeleteQuotaResponse { var response limits.DeleteQuotaResponse quotaIdStr := common.String(quotaId) response, err := client.DeleteQuota(context.Background(), limits.DeleteQuotaRequest{QuotaId: quotaIdStr}) if err != nil { panic(err) } return response } // Example_quotas runs an example demonstrating the use of OCI Golang SDK for managing Quotas func Example_quotas() { // Initialize default config provider configProvider := common.DefaultConfigProvider() if ok, err := common.IsConfigurationProviderValid(configProvider); !ok { panic(err) } // Initialize sample inputs compartmentId, _ := configProvider.TenancyOCID() name := "MyQuota" description := "This is a sample Quota" newDescription := "This is an updated Quota" statements := []string{"Zero test-family quota 'test-quota-1' in tenancy"} // Initialize Quotas client client, err := limits.NewQuotasClientWithConfigurationProvider(configProvider) if err != nil { panic(err) } // Create Quota fmt.Println("Creating Quota") createQuotaDetails := limits.CreateQuotaDetails{CompartmentId: &compartmentId, Name: &name, Description: &description, Statements: statements} createResponse := createQuota(client, createQuotaDetails) // Get Quota fmt.Println("Getting Quota") getQuota(client, *createResponse.Quota.Id) // List Quotas fmt.Println("Listing Quotas") listResponse := listQuotas(client, compartmentId) // Update Quota fmt.Println("Updating Quota") quotaId := *listResponse.Items[0].Id updateQuotaDetails := limits.UpdateQuotaDetails{Description: &newDescription} updateQuota(client, quotaId, updateQuotaDetails) // Delete Quota fmt.Println("Deleting Quota") deleteQuota(client, quotaId) fmt.Println("Example_quotas completed") // Output: // Creating Quota // Getting Quota // Listing Quotas // Updating Quota // Deleting Quota // Example_quotas completed }
▹ Example (ResourceManager)
▾ Example (ResourceManager)
Example_resourceManager for how to do CRUD for Resource Manager Stack The comparement id is read from the environment variable OCI_COMPARTMENT_ID
Code:
package example
import (
"context"
"fmt"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
"github.com/oracle/oci-go-sdk/v65/resourcemanager"
)
// Example_resourceManager for how to do CRUD for Resource Manager Stack
// The comparement id is read from the environment variable OCI_COMPARTMENT_ID
func Example_resourceManager() {
provider := common.DefaultConfigProvider()
client, err := resourcemanager.NewResourceManagerClientWithConfigurationProvider(provider)
helpers.FatalIfError(err)
ctx := context.Background()
stackID := createStack(ctx, provider, client)
defer deleteStack(ctx, stackID, client)
listStacks(ctx, client)
updateStack(ctx, stackID, client)
getStack(ctx, stackID, client)
// Output:
// create stack completed
// list stacks completed
// update stack completed
// get stack completed
// delete stack completed
}
func createStack(ctx context.Context, provider common.ConfigurationProvider, client resourcemanager.ResourceManagerClient) string {
stackName := fmt.Sprintf("test-%s", helpers.GetRandomString(8))
region, _ := provider.Region()
tenancyOcid, _ := provider.TenancyOCID()
// create resource manager stack with type ZIP_UPLOAD by passing a base64 encoded Terraform zip string
// user has multiple ways to create stack, details check https://docs.oracle.com/iaas/iaas/api/#/en/resourcemanager/20180917/datatypes/CreateConfigSourceDetails
req := resourcemanager.CreateStackRequest{
CreateStackDetails: resourcemanager.CreateStackDetails{
CompartmentId: helpers.CompartmentID(),
ConfigSource: resourcemanager.CreateZipUploadConfigSourceDetails{
WorkingDirectory: common.String("vcn"),
ZipFileBase64Encoded: common.String("[pls use your base64 encoded TF template]"),
},
DisplayName: common.String(stackName),
Description: common.String(fmt.Sprintf("%s-description", stackName)),
Variables: map[string]string{
"compartment_ocid": *helpers.CompartmentID(),
"region": region,
"tenancy_ocid": tenancyOcid,
},
},
}
stackResp, err := client.CreateStack(ctx, req)
helpers.FatalIfError(err)
fmt.Println("create stack completed")
return *stackResp.Stack.Id
}
func updateStack(ctx context.Context, stackID string, client resourcemanager.ResourceManagerClient) {
stackName := fmt.Sprintf("test-v1-%s", helpers.GetRandomString(8))
// update displayName and description of resource manager stack
req := resourcemanager.UpdateStackRequest{
StackId: common.String(stackID),
UpdateStackDetails: resourcemanager.UpdateStackDetails{
DisplayName: common.String(stackName),
Description: common.String(fmt.Sprintf("%s-description", stackName)),
},
}
_, err := client.UpdateStack(ctx, req)
helpers.FatalIfError(err)
fmt.Println("update stack completed")
}
func listStacks(ctx context.Context, client resourcemanager.ResourceManagerClient) {
req := resourcemanager.ListStacksRequest{
CompartmentId: helpers.CompartmentID(),
}
// list resource manager stack
_, err := client.ListStacks(ctx, req)
helpers.FatalIfError(err)
fmt.Println("list stacks completed")
}
func getStack(ctx context.Context, stackID string, client resourcemanager.ResourceManagerClient) {
req := resourcemanager.GetStackRequest{
StackId: common.String(stackID),
}
// get details a particular resource manager stack
_, err := client.GetStack(ctx, req)
helpers.FatalIfError(err)
fmt.Println("get stack completed")
}
func deleteStack(ctx context.Context, stackID string, client resourcemanager.ResourceManagerClient) {
req := resourcemanager.DeleteStackRequest{
StackId: common.String(stackID),
}
// delete a resource manager stack
_, err := client.DeleteStack(ctx, req)
helpers.FatalIfError(err)
fmt.Println("delete stack completed")
}
▹ Example (ResourceSearch)
▾ Example (ResourceSearch)
Code:
client, err := resourcesearch.NewResourceSearchClientWithConfigurationProvider(common.DefaultConfigProvider()) ctx := context.Background() helpers.FatalIfError(err) // list resource types listReq := resourcesearch.ListResourceTypesRequest{} listResp, err := client.ListResourceTypes(ctx, listReq) fmt.Println("list resource types") for _, element := range listResp.Items { log.Printf("Resource: %s", *element.Name) } // get group type details getReq := resourcesearch.GetResourceTypeRequest{ Name: common.String("Group"), } getResp, err := client.GetResourceType(context.Background(), getReq) helpers.FatalIfError(err) fmt.Println("get group type details") log.Printf("Resource type: %s", getResp.ResourceType) // search resource by freetext searchReq := resourcesearch.SearchResourcesRequest{ SearchDetails: resourcesearch.FreeTextSearchDetails{ Text: common.String("displayname"), }, } freeSearchResp, err := client.SearchResources(context.Background(), searchReq) helpers.FatalIfError(err) fmt.Println("search resource by freetext") for _, element := range freeSearchResp.Items { log.Printf("Resource: %s", element) } searchReq.SearchDetails = resourcesearch.StructuredSearchDetails{ MatchingContextType: resourcesearch.SearchDetailsMatchingContextTypeHighlights, Query: common.String("query all resources"), } structureSearchResp, err := client.SearchResources(context.Background(), searchReq) helpers.FatalIfError(err) // search resource by structured query fmt.Println("search resource by structured query") for _, element := range structureSearchResp.Items { log.Printf("Resource: %s", element) }
Output:
list resource types get group type details search resource by freetext search resource by structured query
▹ Example (Tagging)
▾ Example (Tagging)
Example_tagging shows the sample for tag and tagNamespace operations: create, update, get, list etc...
Code:
c, err := identity.NewIdentityClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
ctx := context.Background()
tagNamespaceID := createTagNamespace(ctx, c, common.String("GOSDKSampleTagNamespaceName"))
fmt.Println("tag namespace created")
tagName := common.String("GOSDKSampleTagName")
createTag(ctx, c, tagNamespaceID, tagName)
fmt.Println("tag created")
// get tag
getTagReq := identity.GetTagRequest{
TagNamespaceId: tagNamespaceID,
TagName: tagName,
}
_, err = c.GetTag(ctx, getTagReq)
helpers.FatalIfError(err)
fmt.Println("get tag")
// list tags, list operations are paginated and take a "page" parameter
// to allow you to get the next batch of items from the server
// for pagination sample, please refer to 'example_core_pagination_test.go'
listTagReq := identity.ListTagsRequest{
TagNamespaceId: tagNamespaceID,
}
_, err = c.ListTags(ctx, listTagReq)
helpers.FatalIfError(err)
fmt.Println("list tag")
// get tag namespace
getTagNamespaceReq := identity.GetTagNamespaceRequest{
TagNamespaceId: tagNamespaceID,
}
_, err = c.GetTagNamespace(ctx, getTagNamespaceReq)
helpers.FatalIfError(err)
fmt.Println("get tag namespace")
// list tag namespaces
listTagNamespaceReq := identity.ListTagNamespacesRequest{
CompartmentId: helpers.CompartmentID(),
}
_, err = c.ListTagNamespaces(ctx, listTagNamespaceReq)
helpers.FatalIfError(err)
fmt.Println("list tag namespace")
// retire a tag namespace by using the update tag namespace operation
updateTagNamespaceReq := identity.UpdateTagNamespaceRequest{
TagNamespaceId: tagNamespaceID,
UpdateTagNamespaceDetails: identity.UpdateTagNamespaceDetails{
IsRetired: common.Bool(true),
},
}
_, err = c.UpdateTagNamespace(ctx, updateTagNamespaceReq)
helpers.FatalIfError(err)
fmt.Println("tag namespace retired")
// retire a tag by using the update tag operation
updateTagReq := identity.UpdateTagRequest{
TagNamespaceId: tagNamespaceID,
TagName: tagName,
UpdateTagDetails: identity.UpdateTagDetails{
IsRetired: common.Bool(true),
},
}
_, err = c.UpdateTag(ctx, updateTagReq)
helpers.FatalIfError(err)
fmt.Println("tag retired")
// reactivate a tag namespace
updateTagNamespaceReq = identity.UpdateTagNamespaceRequest{
TagNamespaceId: tagNamespaceID,
UpdateTagNamespaceDetails: identity.UpdateTagNamespaceDetails{
// reactivate a tag namespace by using the update tag namespace operation
IsRetired: common.Bool(false),
},
}
_, err = c.UpdateTagNamespace(ctx, updateTagNamespaceReq)
helpers.FatalIfError(err)
fmt.Println("tag namespace reactivated")
Output:
tag namespace created tag created get tag list tag get tag namespace list tag namespace tag namespace retired tag retired tag namespace reactivated
▹ Example (UnlimitedAttemptsRetry)
▾ Example (UnlimitedAttemptsRetry)
Example_unlimitedAttemptsRetry shows how to use retry with unlimited retries, only limited by time, for Create and Delete groups, please refer to example_core_test.go->Example_launchInstance for more examples
Code:
// create and delete group with retry client, clerr := identity.NewIdentityClientWithConfigurationProvider(common.DefaultConfigProvider()) ctx := context.Background() helpers.FatalIfError(clerr) request := identity.CreateGroupRequest{} request.CompartmentId = helpers.RootCompartmentID() request.Name = common.String("GoSDK_Sample_Group") request.Description = common.String("GoSDK Sample Group Description") maximumCumulativeBackoff := time.Duration(2) * time.Minute // retry unlimited number of times, up to two minutes customRetryPolicy := common.NewRetryPolicyWithOptions( common.WithUnlimitedAttempts(maximumCumulativeBackoff), common.WithShouldRetryOperation(func(r common.OCIOperationResponse) bool { durationSinceInitialAttempt := time.Since(r.InitialAttemptTime) tooLong := durationSinceInitialAttempt > maximumCumulativeBackoff return common.DefaultShouldRetryOperation(r) && !tooLong }), common.WithNextDuration(func(r common.OCIOperationResponse) time.Duration { return time.Duration(math.Pow(float64(2), float64(r.AttemptNumber-1))) * time.Second }), ) // create request metadata for retry request.RequestMetadata = common.RequestMetadata{ RetryPolicy: &customRetryPolicy, } resp, err := client.CreateGroup(ctx, request) helpers.FatalIfError(err) fmt.Println("Creating Group") // Get with polling shouldRetry := func(r common.OCIOperationResponse) bool { if _, isServiceError := common.IsServiceError(r.Error); isServiceError { // not service error, could be network error or other errors which prevents // request send to server, will do retry here return true } if converted, ok := r.Response.(identity.GetGroupResponse); ok { // do the retry until lifecycle state become active return converted.LifecycleState != identity.GroupLifecycleStateActive } return true } // retry unlimited number of times, up to two minutes, until lifecycle state is active lifecycleStateCheckRetryPolicy := common.NewRetryPolicyWithOptions( // since this retries on ANY error response, we don't need special handling for eventual consistency common.ReplaceWithValuesFromRetryPolicy(common.DefaultRetryPolicyWithoutEventualConsistency()), common.WithUnlimitedAttempts(maximumCumulativeBackoff), common.WithShouldRetryOperation(func(r common.OCIOperationResponse) bool { durationSinceInitialAttempt := time.Since(r.InitialAttemptTime) tooLong := durationSinceInitialAttempt > maximumCumulativeBackoff return shouldRetry(r) && !tooLong }), common.WithNextDuration(func(r common.OCIOperationResponse) time.Duration { return time.Duration(math.Pow(float64(2), float64(r.AttemptNumber-1))) * time.Second }), ) getRequest := identity.GetGroupRequest{ GroupId: resp.Id, RequestMetadata: common.RequestMetadata{ RetryPolicy: &lifecycleStateCheckRetryPolicy, }, } _, errAfterPolling := client.GetGroup(ctx, getRequest) helpers.FatalIfError(errAfterPolling) fmt.Println("Group Created") defer func() { // if we've successfully created a group, make sure that we delete it rDel := identity.DeleteGroupRequest{ GroupId: resp.Id, RequestMetadata: common.RequestMetadata{ RetryPolicy: &customRetryPolicy, }, } _, err = client.DeleteGroup(ctx, rDel) helpers.FatalIfError(err) fmt.Println("Group Deleted") }()
Output:
Creating Group Group Created Group Deleted
▹ Example (UpdateAdb)
▾ Example (UpdateAdb)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
updateDbDetails := database.UpdateAutonomousDatabaseDetails{
CpuCoreCount: common.Int(2),
DataStorageSizeInTBs: common.Int(2),
IsAutoScalingEnabled: common.Bool(false),
}
updateReq := database.UpdateAutonomousDatabaseRequest{
AutonomousDatabaseId: common.String("replacewithvalidocid"),
UpdateAutonomousDatabaseDetails: updateDbDetails,
}
_, err := c.UpdateAutonomousDatabase(context.Background(), updateReq)
helpers.FatalIfError(err)
fmt.Println("update adb successful")
Output:
update adb successful
▹ Example (UpdateAdbAcl)
▾ Example (UpdateAdbAcl)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
updateDbDetails := database.UpdateAutonomousDatabaseDetails{
WhitelistedIps: []string{"1.1.1.1/28", "3.3.3.3"},
}
updateReq := database.UpdateAutonomousDatabaseRequest{
AutonomousDatabaseId: common.String("replacewithvalidocid"),
UpdateAutonomousDatabaseDetails: updateDbDetails,
}
_, err := c.UpdateAutonomousDatabase(context.Background(), updateReq)
helpers.FatalIfError(err)
fmt.Println("update adb acl successful")
Output:
update adb acl successful
▹ Example (UpdateAdbLisenceType)
▾ Example (UpdateAdbLisenceType)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
updateDbDetails := database.UpdateAutonomousDatabaseDetails{
LicenseModel: database.UpdateAutonomousDatabaseDetailsLicenseModelLicenseIncluded,
}
updateReq := database.UpdateAutonomousDatabaseRequest{
AutonomousDatabaseId: common.String("replacewithvalidocid"),
UpdateAutonomousDatabaseDetails: updateDbDetails,
}
_, err := c.UpdateAutonomousDatabase(context.Background(), updateReq)
helpers.FatalIfError(err)
fmt.Println("update adb license type successful")
Output:
update adb license type successful
▹ Example (UpdateBackupDestination)
▾ Example (UpdateBackupDestination)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
updateBackupDestinationDetails := database.UpdateBackupDestinationDetails{
LocalMountPointPath: &localMountPath,
}
updatebackupdestinationReq := database.UpdateBackupDestinationRequest{
UpdateBackupDestinationDetails: updateBackupDestinationDetails,
BackupDestinationId: common.String("backup-destination-ocid"),
}
_, err := c.UpdateBackupDestination(context.Background(), updatebackupdestinationReq)
helpers.FatalIfError(err)
fmt.Println("update backup destination is successful")
Output:
update backup destination is successful
▹ Example (UpdateDbBackupBackupDestination)
▾ Example (UpdateDbBackupBackupDestination)
Code:
c, clerr := database.NewDatabaseClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
backupDestination := database.BackupDestinationDetails{
Type: database.BackupDestinationDetailsTypeEnum("NFS"),
Id: common.String("backup-destination-ocid"),
}
dbBackupConfig := database.DbBackupConfig{
BackupDestinationDetails: []database.BackupDestinationDetails{backupDestination},
}
updatedatabaseDetails := database.UpdateDatabaseDetails{
DbBackupConfig: &dbBackupConfig,
}
updateDatabaseReq := database.UpdateDatabaseRequest{
UpdateDatabaseDetails: updatedatabaseDetails,
DatabaseId: common.String("database-ocid"),
}
_, err := c.UpdateDatabase(context.Background(), updateDatabaseReq)
helpers.FatalIfError(err)
fmt.Println("update backup destination is successful")
Output:
update backup destination is successful
▹ Example (VaultOperations)
▾ Example (VaultOperations)
ExampleKeyManagement_VaultOperations shows how to create, schedule deletion and cancel a scheduled deletion of a KMS vault
Code:
vaultClient, clientError := keymanagement.NewKmsVaultClientWithConfigurationProvider(common.DefaultConfigProvider()) helpers.FatalIfError(clientError) ctx := context.Background() vaultName := "KmsVault" updatedVaultName := "UpdatedKmsVault" vault := createVault(ctx, vaultClient, vaultName) defer cleanupResources(ctx, vaultClient, vault.Id) // wait for instance lifecycle state becomes active waitForStateVaultClient(ctx, vault.Id, vaultClient, keymanagement.VaultLifecycleStateActive) updatedVault := updateVault(ctx, vaultClient, &updatedVaultName, vault.Id) fmt.Printf("Updated vault display name %s\n", *updatedVault.DisplayName) svdErr := scheduleVaultDeletion(ctx, vaultClient, vault.Id) helpers.FatalIfError(svdErr) waitForStateVaultClient(ctx, vault.Id, vaultClient, keymanagement.VaultLifecycleStatePendingDeletion) cvdErr := cancelVaultDeletion(ctx, vaultClient, vault.Id) helpers.FatalIfError(cvdErr) waitForStateVaultClient(ctx, vault.Id, vaultClient, keymanagement.VaultLifecycleStateActive) // Move to root compartment changeVaultCompartment(ctx, vaultClient, helpers.RootCompartmentID(), vault.Id) waitForStateVaultClient(ctx, vault.Id, vaultClient, keymanagement.VaultLifecycleStateActive)
Output:
create vault update vault schedule vault deletion cancel vault deletion change vault compartment schedule vault deletion
▹ Example (WorkRequestQuery)
▾ Example (WorkRequestQuery)
Example for work request query
Code:
ctx := context.Background()
c, clerr := containerengine.NewContainerEngineClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(clerr)
workRequestID := common.String("[YOUR WORK REQUEST ID]")
listErrorReq := containerengine.ListWorkRequestErrorsRequest{
CompartmentId: helpers.CompartmentID(),
WorkRequestId: workRequestID,
}
_, err := c.ListWorkRequestErrors(ctx, listErrorReq)
helpers.FatalIfError(err)
fmt.Println("list work request errors")
listLogReq := containerengine.ListWorkRequestLogsRequest{
CompartmentId: helpers.CompartmentID(),
WorkRequestId: workRequestID,
}
_, err = c.ListWorkRequestLogs(ctx, listLogReq)
helpers.FatalIfError(err)
fmt.Println("list work request logs")
Output:
list work request errors list work request logs
▹ Example (WorkRequests)
▾ Example (WorkRequests)
Code:
package example
import (
"context"
"fmt"
"log"
"github.com/oracle/oci-go-sdk/v65/common"
"github.com/oracle/oci-go-sdk/v65/example/helpers"
"github.com/oracle/oci-go-sdk/v65/workrequests"
)
func Example_workRequests() {
client, err := workrequests.NewWorkRequestClientWithConfigurationProvider(common.DefaultConfigProvider())
helpers.FatalIfError(err)
compartmentID, err := common.DefaultConfigProvider().TenancyOCID()
if err != nil {
log.Println("Coulnd't read Tenancy from OCI config", err)
}
log.Println("Compartment ID: ", compartmentID)
ctx := context.Background()
workRequests := listWorkRequests(ctx, client, compartmentID)
log.Println(len(workRequests), " Work Requests found.")
for _, workRequest := range workRequests {
getPrintSummary(ctx, client, workRequest.Id)
getPrintErrors(ctx, client, workRequest.Id)
getPrintLogs(ctx, client, workRequest.Id)
}
fmt.Println("Work Request example Completed")
// Output: Work Request example Completed
}
func listWorkRequests(ctx context.Context, client workrequests.WorkRequestClient, compartmentID string) []workrequests.WorkRequestSummary {
request := workrequests.ListWorkRequestsRequest{
CompartmentId: &compartmentID,
Limit: common.Int(5),
}
resp, err := client.ListWorkRequests(ctx, request)
helpers.FatalIfError(err)
return resp.Items
}
func getPrintSummary(ctx context.Context, client workrequests.WorkRequestClient, workRequestId *string) {
request := workrequests.GetWorkRequestRequest{
WorkRequestId: workRequestId,
}
resp, err := client.GetWorkRequest(ctx, request)
helpers.FatalIfError(err)
printSummary(resp.WorkRequest)
}
func printSummary(w workrequests.WorkRequest) {
log.Println("")
log.Println("")
log.Println("==========================================================")
log.Printf("Work Request Details: %s\n", *w.Id)
log.Println("==========================================================")
log.Println("OperationType: ", *w.OperationType)
log.Println("Status: ", w.Status)
log.Println("ID: ", *w.Id)
log.Println("CompartmentId: ", *w.CompartmentId)
log.Println("PercentComplete: ", *w.PercentComplete)
log.Println("TimeAccepted: ", *w.TimeAccepted)
log.Println("TimeStarted: ", *w.TimeStarted)
log.Println("TimeFinished: ", *w.TimeFinished)
log.Println("")
}
func getPrintErrors(ctx context.Context, client workrequests.WorkRequestClient, workRequestId *string) {
request := workrequests.ListWorkRequestErrorsRequest{
WorkRequestId: workRequestId,
}
resp, err := client.ListWorkRequestErrors(ctx, request)
helpers.FatalIfError(err)
log.Println("==========================================================")
log.Println("Work Request Errors")
log.Println("==========================================================")
for _, wrErr := range resp.Items {
printErrors(wrErr)
}
log.Println("")
}
func printErrors(wrErr workrequests.WorkRequestError) {
log.Println("{")
log.Println(" Code: ", *wrErr.Code)
log.Println(" Message: ", *wrErr.Message)
log.Println(" Timestamp: ", *wrErr.Timestamp)
log.Println("}")
}
func getPrintLogs(ctx context.Context, client workrequests.WorkRequestClient, workRequestId *string) {
request := workrequests.ListWorkRequestLogsRequest{
WorkRequestId: workRequestId,
Limit: common.Int(10),
}
// example showing how to use the pagination feature.
// Other work request calls can also be paginated but aren't for simplicity.
listLogsFunc := func(request workrequests.ListWorkRequestLogsRequest) (workrequests.ListWorkRequestLogsResponse, error) {
return client.ListWorkRequestLogs(ctx, request)
}
log.Println("==========================================================")
log.Println("Work Request Logs")
log.Println("==========================================================")
for resp, err := listLogsFunc(request); ; resp, err = listLogsFunc(request) {
helpers.FatalIfError(err)
for _, wrLog := range resp.Items {
printLogs(wrLog)
}
if resp.OpcNextPage != nil {
// if there are more items in next page, fetch items from next page
request.Page = resp.OpcNextPage
} else {
// no more result, break the loop
break
}
}
log.Println("")
}
func printLogs(wrLog workrequests.WorkRequestLogEntry) {
log.Println("{")
log.Println(" Message: ", *wrLog.Message)
log.Println(" Timestamp: ", *wrLog.Timestamp)
log.Println("}")
}
func ExampleGenerateText()
| Name | Synopsis |
|---|---|
| .. | |
| container_image_signing | |
| example_resource_principal_function | |
| helpers | |