Compartir vía

Inicio rápido: Administración de secretos mediante la biblioteca cliente de Go en Azure Key Vault

  • Artículo

En este inicio rápido, aprenderá a usar Azure SDK para Go para crear, recuperar, enumerar y eliminar secretos de Azure Key Vault.

Puede almacenar diversos tipos de objetos en un almacén de claves de Azure. Al almacenar secretos en un almacén de claves, evita tener que almacenarlos en el código, lo que ayuda a mejorar la seguridad de las aplicaciones.

Comience con el paquete azsecrets y aprenda a administrar los secretos en una instancia de Azure Key Vault con Go.

Prerrequisitos

Configuración

Para los fines de este inicio rápido, usará el paquete azidentity para autenticarse en Azure mediante la CLI de Azure. Para más información sobre los diferentes métodos de autenticación, consulte Autenticación de Azure con Azure SDK para Go.

Inicio de sesión en Azure Portal

  1. Ejecute el siguiente comando en la CLI de Azure:

    az login

    Si la CLI de Azure puede abrir el explorador predeterminado, lo hará en la página de inicio de sesión de Azure.

    Si la página no se abre automáticamente, vaya a https://aka.ms/devicelogin y escriba el código de autorización que se muestra en el terminal.

  2. Inicie sesión en Azure Portal con las credenciales de su cuenta.

Creación de un grupo de recursos y de un almacén de claves

En este inicio rápido se usa un almacén de claves de Azure creado previamente. Puede crear un almacén de claves siguiendo los pasos descritos en el inicio rápido de CLI de Azure, inicio rápido de Azure PowerShell o inicio rápido de Azure Portal.

Como alternativa, puede ejecutar estos comandos de la CLI de Azure o Azure PowerShell.

Importante

Cada almacén de claves debe tener un nombre único. Reemplace <nombre-almacén de claves-único> por el nombre del almacén de claves en los siguientes ejemplos.

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

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

Concesión de acceso al almacén de claves

Para obtener permisos para el almacén de claves mediante Control de acceso basado en roles (RBAC), asigne un rol a su "Nombre principal de usuario" (UPN) mediante el comando de la CLI de Azure 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>"

Reemplace <upn>, <subscription-id>, <resource-group-name> y <your-unique-keyvault-name> por los valores reales. El UPN normalmente tendrá el formato de una dirección de correo electrónico (por ejemplo, username@domain.com).

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

Ejecute los siguientes comandos de 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

Código de ejemplo

Cree un archivo llamado main.go y pegue dentro el código siguiente:

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

Ejecución del código

  1. 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 del almacén de claves que creó previamente.

    export KEY_VAULT_NAME=quickstart-kv

  2. Para iniciar la aplicación Go, ejecute e comando siguiente:

    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

Ejemplos de código

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

Limpieza de recursos

Elimine el grupo de recursos y todos los recursos restantes mediante este comando:

az group delete --resource-group quickstart-rg

Pasos siguientes