Partager via

Démarrage rapide : gérer les secrets à l’aide de la bibliothèque de client Azure Key Vault Go

Dans ce guide de démarrage rapide, vous allez apprendre à utiliser le Kit de développement logiciel (SDK) Azure pour Go pour créer, récupérer, répertorier et supprimer des secrets d’un coffre de clés Azure.

Vous pouvez stocker différents types d’objets dans un coffre de clés Azure. Lorsque vous stockez des secrets dans un coffre de clés, vous évitez d’avoir à les stocker dans votre code, ce qui permet d’améliorer la sécurité de vos applications.

Prenez en main le package azsecrets et apprenez à gérer vos secrets dans un coffre de clés Azure à l’aide de Go.

Prerequisites

Setup

Dans le cadre de ce guide de démarrage rapide, vous utilisez le package azidentity pour vous authentifier auprès d’Azure à l’aide de l’interface de ligne de commande Azure. Pour en savoir plus sur les différentes méthodes d’authentification, consultez Authentification Azure avec Azure SDK pour Go.

Connectez-vous au portail Azure.

  1. Dans Azure CLI, exécutez la commande suivante :

    az login

    Si Azure CLI peut ouvrir votre navigateur par défaut, il le fait sur la page de connexion au portail Azure.

    Si la page ne s’ouvre pas automatiquement, accédez à https://aka.ms/devicelogin, puis entrez le code d’autorisation affiché dans votre terminal.

  2. Connectez-vous au portail Azure à l’aide des informations d’identification de votre compte.

Créer un groupe de ressources et un coffre de clés

Ce guide de démarrage rapide utilise un coffre de clés Azure préalablement créé. Vous pouvez créer un coffre de clés en suivant les étapes décrites dans ces démarrage rapides :

Vous pouvez également exécuter ces commandes Azure CLI.

Important

Chaque coffre de clés doit avoir un nom unique. Remplacez <your-unique-keyvault-name> par le nom de votre coffre de clés dans les exemples suivants.

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

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

Accorder l’accès à votre coffre de clés

Pour obtenir des autorisations sur votre coffre de clés par le biais du contrôle d’accès en fonction du rôle (RBAC), attribuez un rôle à votre « nom d’utilisateur principal » (UPN) à l’aide de la commande 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>"

Remplacez <upn>, <subscription-id>, <resource-group-name> et <your-unique-keyvault-name> par vos valeurs réelles. Votre nom d’utilisateur principal (UPN) se présente généralement sous la forme d’une adresse électronique (par exemple username@domain.com).

Créer un nouveau module Go et installer des packages

Exécutez les commandes Go suivantes :

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

Exemple de code

Créez un fichier nommé main.go et collez-y le code suivant :

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

Exécuter le code

  1. Avant d’exécuter le code, créez une variable d’environnement nommée KEY_VAULT_NAME. Définissez la valeur de la variable d’environnement en spécifiant le nom du coffre de clés Azure que vous avez créé précédemment.

    export KEY_VAULT_NAME=quickstart-kv

  2. Pour lancer l’application Go, exécutez la commande suivante :

    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

Exemples de code

Pour plus d’exemples, consultez la documentation du module.

Nettoyer les ressources

Supprimez le groupe de ressources et toutes ses ressources restantes en exécutant la commande suivante :

az group delete --resource-group quickstart-rg

Étapes suivantes

  • Last updated on