Schnellstart: Azure Key Vault-Clientbibliothek für Go

In dieser Schnellstartanleitung erfahren Sie, wie Sie das Azure SDK für Go verwenden, um Azure Key Vault-Schlüssel zu erstellen, abzurufen, zu aktualisieren und zu löschen.

Azure Key Vault ist ein Clouddienst, der als sicherer Geheimnisspeicher fungiert. Dadurch können Schlüssel, Kennwörter, Zertifikate und andere Geheimnisse sicher gespeichert werden. Weitere Informationen zu Key Vault finden Sie in der Übersicht.

In dieser Anleitung erfahren Sie, wie Sie das Paket azkeys verwenden, um Ihre Azure Key Vault-Schlüssel mit Go zu verwalten.

Voraussetzungen

• Azure-Abonnement (kostenloses Abonnement erstellen)
• Installation von Go: Version 1.18 oder höher
• Azure-Befehlszeilenschnittstelle

Melden Sie sich auf dem Azure-Portal an.

1. Führen Sie in der Azure-Befehlszeilenschnittstelle den folgenden Befehl aus:

   az login
   

   Die Azure CLI öffnet Ihren Standardbrowser, sofern sie dazu in der Lage ist, und lädt die Anmeldeseite des Azure-Portals.

   Falls die Seite nicht automatisch geöffnet wird, rufen Sie https://aka.ms/devicelogin auf, und geben Sie den in Ihrem Terminal angezeigten Autorisierungscode ein.

2. Melden Sie sich mit den Anmeldeinformationen Ihres Kontos beim Azure-Portal an.

Erstellen einer Ressourcengruppe und eines Schlüsseltresors

In dieser Schnellstartanleitung wird eine vorab erstellte Azure Key Vault-Instanz verwendet. Eine Anleitung zum Erstellen eines Schlüsseltresors finden Sie unter Schnellstart: Festlegen eines Geheimnisses und Abrufen des Geheimnisses aus Azure Key Vault mithilfe der Azure CLI, Schnellstart: Festlegen eines Geheimnisses und Abrufen des Geheimnisses aus Azure Key Vault mithilfe von PowerShell oder Schnellstart: Festlegen eines Geheimnisses und Abrufen des Geheimnisses aus Azure Key Vault mithilfe des Azure-Portals.

Alternativ können Sie diese Azure CLI- oder Azure PowerShell-Befehle ausführen.

Wichtig

Jeder Schlüsseltresor muss einen eindeutigen Namen haben. Ersetzen Sie in den folgenden Beispielen <your-unique-keyvault-name> durch den Namen Ihres Schlüsseltresors.

Azure-Befehlszeilenschnittstelle

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

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

Azure PowerShell

New-AzResourceGroup -Name myResourceGroup -Location eastus

New-AzKeyVault -Name <your-unique-keyvault-name> -ResourceGroupName myResourceGroup -Location eastus

Gewähren des Zugriffs auf Ihren Schlüsseltresor

Um Ihrem Benutzerprinzipalnamen (User Principal Name, UPN) über die rollenbasierte Zugriffssteuerung (Role-Based Access Control, RBAC) Berechtigungen für Ihren Schlüsseltresor zu gewähren, weisen Sie ihm mithilfe des Azure CLI-Befehls az role assignment create eine Rolle zu.

az role assignment create --role "Key Vault Crypto Officer" --assignee "<upn>" --scope "/subscriptions/<subscription-id>/resourceGroups/<resource-group-name>/providers/Microsoft.KeyVault/vaults/<your-unique-keyvault-name>"

Ersetzen Sie <upn>, <subscription-id>, <resource-group-name> und <your-unique-keyvault-name> durch Ihre tatsächlichen Werte. Ihr Benutzerprinzipalname (UPN) hat in der Regel das Format einer E-Mail-Adresse (z. B. username@domain.com).

Erstellen eines neuen Go-Moduls und Installieren von Paketen

Führen Sie die folgenden Go-Befehle aus:

go mod init quickstart-keys
go get -u github.com/Azure/azure-sdk-for-go/sdk/azidentity
go get -u github.com/Azure/azure-sdk-for-go/sdk/keyvault/azkeys

Erstellen des Beispielcodes

Erstellen Sie eine Datei mit dem Namen „main.go“, und kopieren Sie den folgenden Code in die Datei:

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"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/azkeys"
)

func main() {
	keyVaultName := os.Getenv("KEY_VAULT_NAME")
	keyVaultUrl := fmt.Sprintf("https://%s.vault.azure.net/", keyVaultName)

	// create credential
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}

	// create azkeys client
	client, err := azkeys.NewClient(keyVaultUrl, cred, nil)
	if err != nil {
		log.Fatal(err)
	}

	// create RSA Key
	rsaKeyParams := azkeys.CreateKeyParameters{
		Kty:     to.Ptr(azkeys.JSONWebKeyTypeRSA),
		KeySize: to.Ptr(int32(2048)),
	}
	rsaResp, err := client.CreateKey(context.TODO(), "new-rsa-key", rsaKeyParams, nil)
	if err != nil {
		log.Fatalf("failed to create rsa key: %v", err)
	}
	fmt.Printf("New RSA key ID: %s\n", *rsaResp.Key.KID)

	// create EC Key
	ecKeyParams := azkeys.CreateKeyParameters{
		Kty:   to.Ptr(azkeys.JSONWebKeyTypeEC),
		Curve: to.Ptr(azkeys.JSONWebKeyCurveNameP256),
	}
	ecResp, err := client.CreateKey(context.TODO(), "new-ec-key", ecKeyParams, nil)
	if err != nil {
		log.Fatalf("failed to create ec key: %v", err)
	}
	fmt.Printf("New EC key ID: %s\n", *ecResp.Key.KID)

	// list all vault keys
	fmt.Println("List all vault keys:")
	pager := client.NewListKeysPager(nil)
	for pager.More() {
		page, err := pager.NextPage(context.TODO())
		if err != nil {
			log.Fatal(err)
		}
		for _, key := range page.Value {
			fmt.Println(*key.KID)
		}
	}

	// update key properties to disable key
	updateParams := azkeys.UpdateKeyParameters{
		KeyAttributes: &azkeys.KeyAttributes{
			Enabled: to.Ptr(false),
		},
	}
	// an empty string version updates the latest version of the key
	version := ""
	updateResp, err := client.UpdateKey(context.TODO(), "new-rsa-key", version, updateParams, nil)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Key %s Enabled attribute set to: %t\n", *updateResp.Key.KID, *updateResp.Attributes.Enabled)

	// delete the created keys
	for _, keyName := range []string{"new-rsa-key", "new-ec-key"} {
		// DeleteKey returns when Key Vault has begun deleting the key. That can take several
		// seconds to complete, so it may be necessary to wait before performing other operations
		// on the deleted key.
		delResp, err := client.DeleteKey(context.TODO(), keyName, nil)
		if err != nil {
			panic(err)
		}
		fmt.Printf("Successfully deleted key %s", *delResp.Key.KID)
	}
}

Ausführen des Codes

Bevor Sie den Code ausführen, erstellen Sie eine Umgebungsvariable namens KEY_VAULT_NAME. Legen Sie den Wert der Umgebungsvariablen auf den Namen der zuvor erstellten Azure Key Vault-Instanz fest.

export KEY_VAULT_NAME=quickstart-kv

Führen Sie als Nächstes den folgenden go run-Befehl aus, um die App auszuführen:

go run main.go

Key ID: https://quickstart-kv.vault.azure.net/keys/new-rsa-key4/f78fe1f34b064934bac86cc8c66a75c3: Key Type: RSA
Key ID: https://quickstart-kv.vault.azure.net/keys/new-ec-key2/10e2cec51d1749c0a26aab784808cfaf: Key Type: EC
List all vault keys:
https://quickstart-kv.vault.azure.net/keys/new-ec-key
https://quickstart-kv.vault.azure.net/keys/new-ec-key1
https://quickstart-kv.vault.azure.net/keys/new-ec-key2
https://quickstart-kv.vault.azure.net/keys/new-rsa-key4
Enabled set to: false
Successfully deleted key https://quickstart-kv.vault.azure.net/keys/new-rsa-key4/f78fe1f34b064934bac86cc8c66a75c3

Hinweis

Diese Ausgabe dient nur zu Informationszwecken. Ihre Rückgabewerte können je nach Azure-Abonnement und Azure Key Vault-Instanz variieren.

Codebeispiele

Weitere Beispiele finden Sie in der Moduldokumentation.

Bereinigen von Ressourcen

Führen Sie die folgenden Befehle aus, um die Ressourcengruppe und alle dazugehörigen Ressourcen zu löschen:

az group delete --resource-group quickstart-rg

Nächste Schritte

• Übersicht über den Azure-Schlüsseltresor
• Sicherer Zugriff auf einen Schlüsseltresor
• Entwicklerhandbuch zu Azure Key Vault
• Key Vault-Sicherheitsübersicht
• Authentifizieren mit Key Vault