Share via

Guida introduttiva: Gestire i segreti usando la libreria client Go di Azure Key Vault

  • Articolo

In questa guida introduttiva si apprenderà come usare Azure SDK per Go per creare, recuperare, elencare ed eliminare segreti da un insieme di credenziali delle chiavi di Azure.

È possibile archiviare un'ampia gamma di tipi di oggetti in un insieme di credenziali delle chiavi di Azure. Quando si archiviano segreti in un insieme di credenziali delle chiavi, evitare di archiviarli nel codice, migliorando così la sicurezza delle applicazioni.

Introduzione al pacchetto azsecrets e informazioni su come gestire i segreti in un insieme di credenziali delle chiavi di Azure usando Go.

Prerequisiti

Impostazione

Ai fini di questa guida introduttiva, usare il pacchetto azidentity per l'autenticazione in Azure usando l'interfaccia della riga di comando di Azure. Per informazioni sui vari metodi di autenticazione, vedere 'autenticazione di Azure con Azure SDK per Go.

Accedere al portale di Azure

  1. Nell'interfaccia della riga di comando di Azure eseguire il comando seguente:

    az login

    Se l'interfaccia della riga di comando di Azure può aprire il browser predefinito, questa operazione verrà eseguita nella pagina di accesso del portale di Azure.

    Se la pagina non viene aperta automaticamente, passare a https://aka.ms/devicelogin, quindi immettere il codice di autorizzazione visualizzato nel terminale.

  2. Accedere al portale di Azure con le credenziali dell'account.

Creare un gruppo di risorse e un'istanza dell'insieme di credenziali delle chiavi

Eseguire i comandi seguenti dell'interfaccia della riga di comando di Azure:

az group create --name quickstart-rg --location eastus
az keyvault create --name quickstart-kv --resource-group quickstart-rg

Creare un nuovo modulo Go e installare i pacchetti

Eseguire i seguenti comandi 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

Codice di esempio

Creare un file denominato main.go, quindi incollarvi il codice seguente:

package main

import (
    "context"
    "fmt"
    "log"

    "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 := os.Getenv("AZURE_KEY_VAULT_URI")

    // 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")
}

Eseguire il codice

  1. Prima di eseguire il codice, creare una variabile di ambiente denominata KEY_VAULT_NAME. Impostare il valore della variabile di ambiente sul nome dell'insieme di credenziali delle chiavi creato in precedenza.

    export KEY_VAULT_NAME=quickstart-kv

  2. Per avviare l'app Go, eseguire il comando seguente:

    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

Esempi di codice

Per altri esempi, vedere la documentazione del modulo.

Pulire le risorse

Eliminare il gruppo di risorse e tutte le risorse rimanenti eseguendo il comando seguente:

az group delete --resource-group quickstart-rg

Passaggi successivi