Partager via

Démarrage rapide : bibliothèque de client de certificats Azure Key Vault pour Go

  • Article

Dans ce guide de démarrage rapide, vous apprendrez à utiliser le SDK Azure pour Go afin de gérer les certificats dans un Azure Key Vault.

Azure Key Vault est un service cloud qui fonctionne comme un magasin des secrets sécurisé. Vous pouvez stocker des clés, des mots de passe, des certificats et d’autres secrets en toute sécurité. Pour plus d’informations sur Key Vault, consultez la présentation.

Suivez ce guide pour apprendre à utiliser le package azcertificatesafin de gérer vos certificats Azure Key Vault à l’aide de Go.

Prérequis

Connectez-vous au portail Azure

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

    az login

    Si l’interface de ligne de commande Azure peut ouvrir votre navigateur par défaut, elle le fait sur une page de connexion du portail Azure.

    Si la page ne s’ouvre pas automatiquement, allez à https://aka.ms/devicelogin, puis saisissez le code d’autorisation qui s’affiche sur votre terminal.

  2. Connectez-vous au portail Azure avec les informations d’identification de votre compte.

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

Ce démarrage rapide utilise un Azure Key Vault créé au préalable. Vous pouvez créer un coffre de clés en suivant les étapes décrites dans le guide de démarrage rapide d’Azure CLI, le guide de démarrage rapide d’Azure PowerShell ou le guide de démarrage rapide du portail Azure.

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

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 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 Certificate 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 quickstart-go-kvcerts
go get github.com/Azure/azure-sdk-for-go/sdk/keyvault/azcertificates
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity

Créer l’exemple de code

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

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/keyvault/azcertificates"
)

func getClient() *azcertificates.Client {
	keyVaultName := os.Getenv("KEY_VAULT_NAME")
	if keyVaultName == "" {
		log.Fatal("KEY_VAULT_NAME environment variable not set")
	}
	keyVaultUrl := fmt.Sprintf("https://%s.vault.azure.net/", keyVaultName)

	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatal(err)
	}

	return azcertificates.NewClient(keyVaultUrl, cred, nil)
}

func createCert(client *azcertificates.Client) {
	params := azcertificates.CreateCertificateParameters{
		CertificatePolicy: &azcertificates.CertificatePolicy{
			IssuerParameters: &azcertificates.IssuerParameters{
				Name: to.Ptr("Self"),
			},
			X509CertificateProperties: &azcertificates.X509CertificateProperties{
				Subject: to.Ptr("CN=DefaultPolicy"),
			},
		},
	}
	resp, err := client.CreateCertificate(context.TODO(), "myCertName", params, nil)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Requested a new certificate. Operation status: %s\n", *resp.Status)
}

func getCert(client *azcertificates.Client) {
	// an empty string version gets the latest version of the certificate
	version := ""
	getResp, err := client.GetCertificate(context.TODO(), "myCertName", version, nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Enabled set to:", *getResp.Attributes.Enabled)
}

func listCert(client *azcertificates.Client) {
	pager := client.NewListCertificatesPager(nil)
	for pager.More() {
		page, err := pager.NextPage(context.Background())
		if err != nil {
			log.Fatal(err)
		}
		for _, cert := range page.Value {
			fmt.Println(*cert.ID)
		}
	}
}

func updateCert(client *azcertificates.Client) {
	// disables the certificate, sets an expires date, and add a tag
	params := azcertificates.UpdateCertificateParameters{
		CertificateAttributes: &azcertificates.CertificateAttributes{
			Enabled: to.Ptr(false),
			Expires: to.Ptr(time.Now().Add(72 * time.Hour)),
		},
		Tags: map[string]*string{"Owner": to.Ptr("SRE")},
	}
	// an empty string version updates the latest version of the certificate
	version := ""
	_, err := client.UpdateCertificate(context.TODO(), "myCertName", version, params, nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Updated certificate properites: Enabled=false, Expires=72h, Tags=SRE")
}

func deleteCert(client *azcertificates.Client) {
	// DeleteCertificate returns when Key Vault has begun deleting the certificate. That can take several
	// seconds to complete, so it may be necessary to wait before performing other operations on the
	// deleted certificate.
	resp, err := client.DeleteCertificate(context.TODO(), "myCertName", nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Deleted certificate with ID: ", *resp.ID)
}

func main() {
	fmt.Println("Authenticating...")
	client := getClient()

	fmt.Println("Creating a certificate...")
	createCert(client)

	fmt.Println("Getting certificate Enabled property ...")
	getCert(client)

	fmt.Println("Listing certificates...")
	listCert(client)

	fmt.Println("Updating a certificate...")
	updateCert(client)

	fmt.Println("Deleting a certificate...")
	deleteCert(client)
}

Exécuter le code

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 Azure Key Vault créé précédemment.

export KEY_VAULT_NAME=<YourKeyVaultName>

Ensuite, exécutez la commande go run suivante pour exécuter l’application :

go run main.go

Exemples de code

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

Nettoyer les ressources

Exécutez la commande suivante pour supprimer le groupe de ressources et toutes ses ressources restantes :

az group delete --resource-group myResourceGroup

Étapes suivantes