Azure SDK for Go example. LogAnalytics create or update.

main.go

package main

import (
	"fmt"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/arm/operationalinsights"
	"github.com/Azure/go-autorest/autorest"
	"github.com/Azure/go-autorest/autorest/adal"
	"github.com/Azure/go-autorest/autorest/azure"
)

func main() {
	resourceGroup := "SpikeOMS"
	name := "spikesaoms"

	c := map[string]string{
		"AZURE_CLIENT_ID":       os.Getenv("AZURE_CLIENT_ID"),
		"AZURE_CLIENT_SECRET":   os.Getenv("AZURE_CLIENT_SECRET"),
		"AZURE_SUBSCRIPTION_ID": os.Getenv("AZURE_SUBSCRIPTION_ID"),
		"AZURE_TENANT_ID":       os.Getenv("AZURE_TENANT_ID"),
	}

	if err := checkEnvVar(&c); err != nil {
		log.Fatalf("Error: %v", err)
		return
	}

	spt, err := NewServicePrincipalTokenFromCredentials(c, azure.PublicCloud.ResourceManagerEndpoint)
	if err != nil {
		log.Fatalf("Err: %v", err)
		return
	}

	client := operationalinsights.NewWorkspacesClient(c["AZURE_SUBSCRIPTION_ID"])
	client.Authorizer = autorest.NewBearerAuthorizer(spt)
	parameter := operationalinsights.Workspace{
		Location: ToAddress("eastus"),
	}

	cancel := make(chan struct{})
	receive, error := client.CreateOrUpdate(resourceGroup, name, parameter, cancel)
	workspace := <-receive
	err = <-error
	if err != nil {
		log.Fatalf("Error: %v", err)
	}
	log.Printf("ID: %s", *workspace.ID)
	log.Printf("Name: %s", *workspace.Name)
	log.Printf("Type: %s", *workspace.Type)
	log.Printf("Location: %s", *workspace.Location)
	if workspace.Tags != nil {
		for key, value := range *workspace.Tags {
			log.Print("[Tags]: key: ", key, "value: ", value)
		}
	}

	sharedKeys, err := client.GetSharedKeys(resourceGroup, name)
	if err != nil {
		log.Fatalf("Error: %v", err)
	}

	switch workspace.ProvisioningState {
	case operationalinsights.Canceled:
		log.Printf("ProvisioningState: Canceled")
	case operationalinsights.Creating:
		log.Printf("ProvisioningState: Creating")
	case operationalinsights.Deleting:
		log.Printf("ProvisioningState: Deleting")
	case operationalinsights.Failed:
		log.Printf("ProvisioningState: Failed")
	case operationalinsights.ProvisioningAccount:
		log.Printf("ProvisioningState: ProvisioningAccount")
	case operationalinsights.Succeeded:
		log.Printf("ProvisioningState: Succeeded")
	}
	log.Printf("Source: %s", *workspace.Source)
	log.Printf("CustomerID: %s", *workspace.CustomerID)
	log.Printf("PortalURL: %s", *workspace.PortalURL)
	log.Printf("Sku: %s", workspace.Sku.Name)
	log.Printf("RetentionInDays %d", *workspace.RetentionInDays)

	log.Printf("SharedKey: Primary Shared Key: ", *sharedKeys.PrimarySharedKey)
	log.Printf("SharedKey: Shared Secondary Key: ", *sharedKeys.SecondarySharedKey)

	close(cancel)
}

func ToAddress(str string) *string {
	return &str
}

// NewServicePrincipalTokenFromCredentials creates a new ServicePrincipalToken using values of the
// passed credentials map.
func NewServicePrincipalTokenFromCredentials(c map[string]string, scope string) (*adal.ServicePrincipalToken, error) {
	oauthConfig, err := adal.NewOAuthConfig(azure.PublicCloud.ActiveDirectoryEndpoint, c["AZURE_TENANT_ID"])
	if err != nil {
		panic(err)
	}
	return adal.NewServicePrincipalToken(*oauthConfig, c["AZURE_CLIENT_ID"], c["AZURE_CLIENT_SECRET"], scope)
}

func checkEnvVar(envVars *map[string]string) error {
	var missingVars []string
	for varName, value := range *envVars {
		if value == "" {
			missingVars = append(missingVars, varName)
		}
	}
	if len(missingVars) > 0 {
		return fmt.Errorf("Missing environment variables %v", missingVars)
	}
	return nil
}