Inicio rápido: Biblioteca cliente de certificados de Azure Key Vault para Go
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.
export 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
Pasos siguientes
Comentarios
https://aka.ms/ContentUserFeedback.
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea:Enviar y ver comentarios de