Guia de início rápido: biblioteca de cliente de chaves do Azure Key Vault para Go

Neste quickstart, aprendes a usar o Azure SDK para o Go para criar, recuperar, atualizar, listar e eliminar chaves do Azure Key Vault.

O Azure Key Vault é um serviço cloud que funciona como um arquivo de segredos seguro. Pode armazenar chaves, palavras-passe, certificados e outros segredos em segurança. Para obter mais informações sobre o Key Vault, reveja a Descrição Geral.

Siga este guia para aprender como usar o pacote azkeys para gerir as suas chaves do Azure Key Vault usando o Go.

Prerequisites

• Uma assinatura do Azure - crie uma gratuitamente.
• Go instalado: Versão 1.18 ou superior
• da CLI do Azure

Inicie sessão no portal do Azure

1. Na CLI do Azure, execute o seguinte comando:

   az login
   

   Se o Azure CLI conseguir abrir o seu navegador predefinido, abre o navegador para a página de login do portal Azure.

   Se a página não abrir automaticamente, vá para https://aka.ms/devicelogine insira o código de autorização exibido no terminal.

2. Entre no portal do Azure com suas credenciais de conta.

Criar um grupo de recursos e um cofre de chaves

Este guia de início rápido usa um cofre de chaves do Azure pré-criado. Você pode criar um cofre de chaves seguindo as etapas nestes guias rápidos:

• Início rápido da CLI do Azure
• Início rápido do Azure PowerShell
• Guia de início rápido do portal do Azure

Como alternativa, você pode executar esses comandos da CLI do Azure.

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

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

Conceder acesso ao seu cofre de chaves

Para obter permissões para seu cofre de chaves por meio do RBAC (Controle de Acesso Baseado em Função), atribua uma função ao seu "Nome Principal do Usuário" (UPN) usando o comando az role assignment create da CLI do 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>"

Substitua <upn>, <subscription-id>, <resource-group-name> e <your-unique-keyvault-name> pelos seus valores reais. Seu UPN normalmente estará no formato de um endereço de e-mail (por exemplo, username@domain.com).

Crie um novo módulo Go e instale pacotes

Execute os seguintes comandos 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

Criar o código de exemplo

Crie um arquivo chamado main.go e copie o seguinte código para o arquivo:

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

Executar o código

Antes de executar o código, crie uma variável de ambiente chamada KEY_VAULT_NAME. Defina o valor da variável de ambiente como o nome do Cofre de Chaves do Azure criado anteriormente.

export KEY_VAULT_NAME=quickstart-kv

Em seguida, execute o seguinte go run comando para executar o aplicativo:

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

Exemplos de código

Para mais exemplos, consulte a documentação do módulo.

Clean up resources (Limpar recursos)

Execute o seguinte comando para excluir o grupo de recursos e todos os recursos restantes:

az group delete --resource-group quickstart-rg

Próximos passos

• Visão geral do Azure Key Vault
• Acesso seguro a um cofre de chaves
• Guia do desenvolvedor do Azure Key Vault
• Visão geral da segurança do Key Vault
• Autenticar com o Cofre da Chave