Início Rápido: gerenciar segredos usando a biblioteca de clientes Go do Azure Key Vault

  • Artigo

Neste guia de início rápido, você aprenderá a usar o SDK do Azure para linguagem Go com o objetivo de criar, recuperar, listar e excluir segredos do Azure Key Vault.

Você pode armazenar uma variedade de tipos de objetos em um cofre de chaves do Azure. Ao armazenar segredos em um cofre de chaves, evite armazená-los em seu código, o que ajuda a melhorar a segurança de seus aplicativos.

Comece a usar o pacote azsecrets e saiba como gerenciar seus segredos em um cofre de chaves do Azure usando Go.

Pré-requisitos

Instalação

Para fins deste início rápido, use o pacote azidentity para autenticar no Azure usando o CLI do Azure. Para saber mais sobre os vários métodos de autenticação, confira Autenticação do Azure com o SDK do Azure para linguagem Go.

Entre no Portal do Azure

  1. Execute o seguinte comando na CLI do Azure:

    az login

    Se a CLI do Azure puder abrir o navegador padrão, ela o fará na página de entrada do portal do Azure.

    Se a página não abrir automaticamente, acesse https://aka.ms/devicelogin, e então digite o código de autorização que é exibido em seu terminal.

  2. Entre no portal do Azure com as credenciais da sua conta.

Criar um grupo de recursos e um cofre de chaves

Este início rápido usa um Azure Key Vault pré-criado. Você pode criar um cofre de chaves seguindo as etapas no Início rápido da CLI do Azure, no Início rápido do Azure PowerShell ou no Início rápido do portal do Azure.

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

Importante

Cada cofre de chaves deve ter um nome exclusivo. Substitua <seu-nome-de cofre-de-chaves-exclusivo> pelo nome do seu cofre de chaves nos exemplos a seguir.

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

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

Permitir acesso ao cofre de chaves

Para obter permissões para o cofre de chaves por meio do RBAC (controle de acesso baseado em função), atribua uma função ao seu UPN (nome principal do usuário) usando o comando da CLI do 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>"

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

Criar um módulo Go e instalar pacotes

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

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

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

Executar o código

  1. Antes de executar o código, crie uma variável de ambiente chamada KEY_VAULT_NAME. Defina o valor da variável de ambiente para o nome do cofre de chaves que você criou anteriormente.

    export KEY_VAULT_NAME=quickstart-kv

  2. Para iniciar o aplicativo Go, execute o seguinte comando:

    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

Exemplos de código

Confira a documentação do módulo para obter mais exemplos.

Limpar os recursos

Exclua o grupo de recursos e todos os recursos restantes executando o seguinte comando:

az group delete --resource-group quickstart-rg

Próximas etapas