Azure SDK for Go – Samples

package main

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

    "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)

func main() {
    accountName := os.Getenv("AZURE_STORAGE_ACCOUNT")
    accountKey  := os.Getenv("AZURE_STORAGE_ACCESS_KEY")
    container   := "sample-container"
    blobName    := "hello.txt"

    // Create a service client
    cred, err := azblob.NewSharedKeyCredential(accountName, accountKey)
    if err != nil {
        log.Fatalf("credential error: %v", err)
    }
    serviceURL := fmt.Sprintf("https://%s.blob.core.windows.net/", accountName)
    serviceClient, err := azblob.NewServiceClientWithSharedKey(serviceURL, cred, nil)
    if err != nil {
        log.Fatalf("service client error: %v", err)
    }

    // Upload
    containerClient := serviceClient.NewContainerClient(container)
    _, err = containerClient.Create(context.Background(), nil)
    if err != nil {
        log.Printf("container may already exist: %v", err)
    }

    blobClient := containerClient.NewBlockBlobClient(blobName)
    data := []byte("Hello Azure Blob Storage from Go!")
    _, err = blobClient.UploadBuffer(context.Background(), data, azblob.UploadOption{})
    if err != nil {
        log.Fatalf("upload error: %v", err)
    }
    fmt.Println("Upload successful")

    // Download
    downloadResp, err := blobClient.DownloadStream(context.Background(), nil)
    if err != nil {
        log.Fatalf("download error: %v", err)
    }
    downloaded, err := ioutil.ReadAll(downloadResp.Body)
    if err != nil {
        log.Fatalf("read error: %v", err)
    }
    fmt.Printf("Downloaded content: %s\n", string(downloaded))
}

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/Azure/azure-sdk-for-go/sdk/data/azcosmos"
)

type Item struct {
    ID   string `json:"id"`
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    endpoint := os.Getenv("COSMOS_ENDPOINT")
    key      := os.Getenv("COSMOS_KEY")
    database := "SampleDB"
    container := "People"

    // Create client
    cred, err := azcosmos.NewKeyCredential(key)
    if err != nil {
        log.Fatalf("credential error: %v", err)
    }
    client, err := azcosmos.NewClientWithKey(endpoint, cred, nil)
    if err != nil {
        log.Fatalf("client error: %v", err)
    }

    // Create database if not exists
    _, err = client.CreateDatabase(context.Background(), azcosmos.DatabaseProperties{ID: database}, nil)
    if err != nil {
        log.Printf("database may exist: %v", err)
    }

    // Create container if not exists
    cp := azcosmos.ContainerProperties{
        ID: container,
        PartitionKeyDefinition: azcosmos.PartitionKeyDefinition{
            Paths: []string{"/id"},
        },
    }
    _, err = client.CreateContainer(context.Background(), database, cp, nil)
    if err != nil {
        log.Printf("container may exist: %v", err)
    }

    // Insert item
    coll, err := client.NewContainer(database, container)
    if err != nil {
        log.Fatalf("container reference error: %v", err)
    }
    item := Item{ID: "item1", Name: "Alice", Age: 30}
    pk := azcosmos.NewPartitionKeyString(item.ID)
    b, _ := json.Marshal(item)
    _, err = coll.CreateItem(context.Background(), pk, b, nil)
    if err != nil {
        log.Fatalf("create item error: %v", err)
    }
    fmt.Println("Item created")

    // Query items
    query := "SELECT * FROM c WHERE c.age > @age"
    opts := azcosmos.QueryOptions{
        Parameter: []azcosmos.QueryParameter{
            {Name: "@age", Value: 20},
        },
    }
    pager := coll.NewQueryItemsPager(query, pk, &opts)
    fmt.Println("Query results:")
    for pager.More() {
        resp, err := pager.NextPage(context.Background())
        if err != nil {
            log.Fatalf("query error: %v", err)
        }
        for _, r := range resp.Items {
            var i Item
            json.Unmarshal(r, &i)
            fmt.Printf("- %s (%d)\n", i.Name, i.Age)
        }
    }
}

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/Azure/azure-sdk-for-go/sdk/keyvault/azsecrets"
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
)

func main() {
    vaultName := os.Getenv("KEYVAULT_NAME")
    secretName := "SampleSecret"

    // Build the Key Vault URL
    vaultURL := fmt.Sprintf("https://%s.vault.azure.net/", vaultName)

    // Use DefaultAzureCredential for auth (supports env, managed identity, etc.)
    cred, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        log.Fatalf("credential error: %v", err)
    }

    client, err := azsecrets.NewClient(vaultURL, cred, nil)
    if err != nil {
        log.Fatalf("client error: %v", err)
    }

    resp, err := client.GetSecret(context.Background(), secretName, nil)
    if err != nil {
        log.Fatalf("get secret error: %v", err)
    }

    fmt.Printf("Secret value: %s\\n", *resp.Value)
}