Inicio rápido: Biblioteca cliente de certificados de Azure Key Vault para Go

Artículo
01/10/2024

En este inicio rápido, aprenderá a usar el Azure SDK para Go para administrar certificados en una instancia de Azure Key Vault.

Azure Key Vault es un servicio en la nube que funciona como un almacén de secretos seguro. Puede almacenar de forma segura claves, contraseñas, certificados y otros secretos. Para más información sobre Key Vault, puede consultar esta introducción.

Siga esta guía para aprender a usar el paquete azcertificates para administrar los certificados de Azure Key Vault mediante Go.

Requisitos previos

Una suscripción a Azure: cree una cuenta gratuita.
Go instalado: versión 1.18 o posterior
CLI de Azure

Configurar el entorno

Inicie sesión en Azure.
```
az login
```

Cree un nuevo grupo de recursos.

az group create --name myResourceGroup  --location eastus

Implemente una nueva instancia de Key Vault.
```
az keyvault create --name <keyVaultName> --resource-group myResourceGroup
```
Reemplace <keyVaultName> por un nombre que sea único en todo Azure. Normalmente, se usa el nombre personal o de la empresa, junto con otros números e identificadores.

Creación de un módulo de Go e instalación de paquetes

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

Creación del código de ejemplo

Cree un archivo llamado main.go y copie el siguiente código en él:

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

Ejecución del código

Antes de ejecutar el código, cree una variable de entorno llamada KEY_VAULT_NAME. Establezca el valor de la variable de entorno en el nombre de la instancia de Azure Key Vault que creó previamente.

Bash
PowerShell

export KEY_VAULT_NAME=<YourKeyVaultName>

$env:KEY_VAULT_NAME=<YourKeyVaultName>

A continuación, ejecute el siguiente comando go run para ejecutar la aplicación:

go run main.go

Ejemplos de código

Consulte la documentación del módulo para obtener más ejemplos.

Limpieza de recursos

Ejecute el comando siguiente para eliminar el grupo de recursos y todos los recursos que queden:

az group delete --resource-group myResourceGroup

Share via