Szybki start: biblioteka klienta kluczy usługi Azure Key Vault dla języka Go

W tym przewodniku Szybki start dowiesz się, jak używać zestawu Azure SDK for Go do tworzenia, pobierania, aktualizowania, wyświetlania listy i usuwania kluczy usługi Azure Key Vault.

Azure Key Vault to usługa w chmurze, która działa jako bezpieczny magazyn wpisów tajnych. Możesz bezpiecznie przechowywać klucze, hasła, certyfikaty oraz inne wpisy tajne. Aby uzyskać więcej informacji na temat usługi Key Vault, możesz zapoznać się z omówieniem.

Postępuj zgodnie z tym przewodnikiem, aby dowiedzieć się, jak zarządzać kluczami usługi Azure Key Vault przy użyciu języka Go za pomocą pakietu azkeys .

Wymagania wstępne

• Subskrypcja platformy Azure — utwórz bezpłatnie.
• Zainstalowany program Go: wersja 1.18 lub nowsza
• Interfejs wiersza polecenia platformy Azure

Zaloguj się do witryny Azure Portal.

1. W interfejsie wiersza polecenia platformy Azure uruchom następujące polecenie:

   az login
   

   Jeśli interfejs wiersza polecenia platformy Azure może otworzyć domyślną przeglądarkę, zrobi to na stronie logowania w witrynie Azure Portal.

   Jeśli strona nie zostanie otwarta automatycznie, przejdź do https://aka.ms/deviceloginstrony , a następnie wprowadź kod autoryzacji wyświetlany w terminalu.

2. Zaloguj się do witryny Azure Portal przy użyciu poświadczeń konta.

Tworzenie grupy zasobów i magazynu kluczy

W tym przewodniku Szybki start jest używany wstępnie utworzony magazyn kluczy platformy Azure. Magazyn kluczy można utworzyć, wykonując kroki opisane w przewodniku Szybki start interfejsu wiersza polecenia platformy Azure, przewodniku Szybki start dla programu Azure PowerShell lub przewodniku Szybki start w witrynie Azure Portal.

Alternatywnie możesz uruchomić te polecenia interfejsu wiersza polecenia platformy Azure lub programu Azure PowerShell.

Ważne

Każdy magazyn kluczy musi mieć unikatową nazwę. Zastąp <ciąg your-unique-keyvault-name> nazwą magazynu kluczy w poniższych przykładach.

Interfejs wiersza polecenia platformy Azure

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

Udzielanie dostępu do magazynu kluczy

Aby uzyskać uprawnienia do magazynu kluczy za pomocą kontroli dostępu opartej na rolach (RBAC), przypisz rolę do głównej nazwy użytkownika (UPN) przy użyciu polecenia az role assignment create interfejsu wiersza polecenia platformy Azure.

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

Zastąp <wartości upn>, <subscription-id>, <resource-group-name> i <your-unique-keyvault-name> rzeczywistymi wartościami. Nazwa UPN będzie zwykle mieć format adresu e-mail (np. username@domain.com).

Tworzenie nowego modułu języka Go i instalowanie pakietów

Uruchom następujące polecenia języka Go:

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

Tworzenie przykładowego kodu

Utwórz plik o nazwie main.go i skopiuj następujący kod do pliku:

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

Uruchamianie kodu

Przed uruchomieniem kodu utwórz zmienną środowiskową o nazwie KEY_VAULT_NAME. Ustaw wartość zmiennej środowiskowej na nazwę utworzonej wcześniej usługi Azure Key Vault.

export KEY_VAULT_NAME=quickstart-kv

Następnie uruchom następujące go run polecenie, aby uruchomić aplikację:

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

Uwaga

Dane wyjściowe są przeznaczone tylko do celów informacyjnych. Wartości zwracane mogą się różnić w zależności od subskrypcji platformy Azure i usługi Azure Key Vault.

Przykłady kodu

Więcej przykładów można znaleźć w dokumentacji modułu.

Czyszczenie zasobów

Uruchom następujące polecenie, aby usunąć grupę zasobów i wszystkie pozostałe zasoby:

az group delete --resource-group quickstart-rg

Następne kroki

• Omówienie usługi Azure Key Vault
• Bezpieczny dostęp do magazynu kluczy
• Przewodnik dewelopera usługi Azure Key Vault
• Omówienie zabezpieczeń usługi Key Vault
• Uwierzytelnianie za pomocą usługi Key Vault