Sdílet prostřednictvím

Rychlý start: Správa tajných kódů pomocí klientské knihovny Azure Key Vault Go

  • Článek

V tomto rychlém startu se dozvíte, jak pomocí sady Azure SDK for Go vytvářet, načítat, vypisovat a odstraňovat tajné kódy z trezoru klíčů Azure.

Do trezoru klíčů Azure můžete uložit různé typy objektů. Když tajné kódy ukládáte do trezoru klíčů, nemusíte je ukládat do kódu, což pomáhá zlepšit zabezpečení vašich aplikací.

Začněte s balíčkem azsecrets a zjistěte, jak spravovat tajné kódy v trezoru klíčů Azure pomocí Go.

Požadavky

Nastavení

Pro účely tohoto rychlého startu použijete balíček azidentity k ověření v Azure pomocí Azure CLI. Další informace o různých metodách ověřování najdete v tématu Ověřování Azure pomocí sady Azure SDK for Go.

Přihlaste se k portálu Azure Portal.

  1. V Azure CLI spusťte následující příkaz:

    az login

    Pokud azure CLI může otevřít výchozí prohlížeč, provede to na přihlašovací stránce webu Azure Portal.

    Pokud se stránka neotevře automaticky, přejděte na https://aka.ms/deviceloginstránku a zadejte autorizační kód, který se zobrazí v terminálu.

  2. Přihlaste se k webu Azure Portal pomocí přihlašovacích údajů svého účtu.

Vytvoření skupiny prostředků a trezoru klíčů

V tomto rychlém startu se používá předem vytvořený trezor klíčů Azure. Trezor klíčů můžete vytvořit pomocí kroků v rychlém startu Azure CLI, rychlém startu Azure PowerShellu nebo rychlém startu webu Azure Portal.

Alternativně můžete spustit tyto příkazy Azure CLI nebo Azure PowerShellu.

Důležité

Každý trezor klíčů musí mít jedinečný název. Nahraďte <název-unique-keyvault-name> názvem vašeho trezoru klíčů v následujících příkladech.

az group create --name "myResourceGroup" -l "EastUS"

az keyvault create --name "<your-unique-keyvault-name>" -g "myResourceGroup" --enable-rbac-authorization

Udělení přístupu k trezoru klíčů

Pokud chcete získat oprávnění k trezoru klíčů prostřednictvím řízení přístupu na základě role (RBAC), přiřaďte roli k hlavnímu názvu uživatele (UPN) pomocí příkazu Azure CLI az role assignment create.

az role assignment create --role "Key Vault Secrets Officer" --assignee "<upn>" --scope "/subscriptions/<subscription-id>/resourceGroups/<resource-group-name>/providers/Microsoft.KeyVault/vaults/<your-unique-keyvault-name>"

Nahraďte <upn>, <subscription-id>, <resource-group-name> a <your-unique-keyvault-name> skutečnými hodnotami. Hlavní název uživatele (UPN) bude obvykle ve formátu e-mailové adresy (např username@domain.com. ).

Vytvoření nového modulu Go a instalace balíčků

Spusťte následující příkazy Go:

go mod init kvSecrets
go get -u github.com/Azure/azure-sdk-for-go/sdk/keyvault/azsecrets
go get -u github.com/Azure/azure-sdk-for-go/sdk/azidentity

Ukázkový kód

Vytvořte soubor s názvem main.go a vložte do něj následující kód:

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/Azure/azure-sdk-for-go/sdk/keyvault/azsecrets"
)

func main() {
    mySecretName := "secretName01"
    mySecretValue := "secretValue"
    vaultURI := fmt.Sprintf("https://%s.vault.azure.net/", os.Getenv("KEY_VAULT_NAME"))

    // Create a credential using the NewDefaultAzureCredential type.
    cred, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        log.Fatalf("failed to obtain a credential: %v", err)
    }

    // Establish a connection to the Key Vault client
    client, err := azsecrets.NewClient(vaultURI, cred, nil)

    // Create a secret
    params := azsecrets.SetSecretParameters{Value: &mySecretValue}
    _, err = client.SetSecret(context.TODO(), mySecretName, params, nil)
    if err != nil {
        log.Fatalf("failed to create a secret: %v", err)
    }

    // Get a secret. An empty string version gets the latest version of the secret.
    version := ""
    resp, err := client.GetSecret(context.TODO(), mySecretName, version, nil)
    if err != nil {
        log.Fatalf("failed to get the secret: %v", err)
    }

    fmt.Printf("secretValue: %s\n", *resp.Value)

    // List secrets
    pager := client.NewListSecretsPager(nil)
    for pager.More() {
        page, err := pager.NextPage(context.TODO())
        if err != nil {
            log.Fatal(err)
        }
        for _, secret := range page.Value {
            fmt.Printf("Secret ID: %s\n", *secret.ID)
        }
    }

    // Delete a secret. DeleteSecret returns when Key Vault has begun deleting the secret.
    // That can take several seconds to complete, so it may be necessary to wait before
    // performing other operations on the deleted secret.
    delResp, err := client.DeleteSecret(context.TODO(), mySecretName, nil)
    if err != nil {
        log.Fatalf("failed to delete secret: %v", err)
    }

    fmt.Println(delResp.ID.Name() + " has been deleted")
}

Spuštění kódu

  1. Před spuštěním kódu vytvořte proměnnou prostředí s názvem KEY_VAULT_NAME. Nastavte hodnotu proměnné prostředí na název trezoru klíčů, který jste vytvořili dříve.

    export KEY_VAULT_NAME=quickstart-kv

  2. Aplikaci Go spustíte spuštěním následujícího příkazu:

    go run main.go

    secretValue: createdWithGO
Secret ID: https://quickstart-kv.vault.azure.net/secrets/quickstart-secret
Secret ID: https://quickstart-kv.vault.azure.net/secrets/secretName
quickstart-secret has been deleted

Příklady kódu

Další příklady najdete v dokumentaci k modulu.

Vyčištění prostředků

Odstraňte skupinu prostředků a všechny zbývající prostředky spuštěním následujícího příkazu:

az group delete --resource-group quickstart-rg

Další kroky