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

Z tego przewodnika Szybki start dowiesz się, jak zarządzać certyfikatami w usłudze Azure Key Vault przy użyciu zestawu Azure SDK dla języka Go.

Azure Key Vault to usługa chmurowa, która działa jako bezpieczny magazyn sekretów. 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 używać pakietu azcertificates do zarządzania certyfikatami w Azure Key Vault za pomocą języka Go.

Prerequisites

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ę, robi to na stronie logowania w witrynie Azure Portal.

    Jeśli strona nie otworzy się automatycznie, wejdź na https://aka.ms/devicelogin, a następnie wprowadź kod autoryzacji wyświetlany w terminalu.

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

Utwórz grupę zasobów i magazyn kluczy

Ten szybki start wykorzystuje wstępnie utworzony magazyn kluczy Azure. Można utworzyć magazyn kluczy, wykonując kroki opisane w tych szybkich przewodnikach startowych:

Alternatywnie możesz uruchomić te polecenia Azure CLI.

Important

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

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

az keyvault create --name "<vault-name>" -g "myResourceGroup" --enable-rbac-authorization true

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 interfejsu wiersza polecenia platformy Azure az role assignment create.

az role assignment create --role "Key Vault Certificates Officer" --assignee "<upn>" --scope "/subscriptions/<subscription-id>/resourceGroups/myResourceGroup/providers/Microsoft.KeyVault/vaults/<vault-name>"

Zastąp <upn>, <subscription-id> i <vault-name> rzeczywistymi wartościami. Jeśli użyto innej nazwy grupy zasobów, zastąp "myResourceGroup" również. 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-go-kvcerts
go get github.com/Azure/azure-sdk-for-go/sdk/keyvault/azcertificates
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity

Tworzenie przykładowego kodu

Utwórz plik o nazwie main.go i skopiuj następujący fragment kodu w pliku:

Uwaga / Notatka

Ten przewodnik Szybki start tworzy certyfikat z podpisem własnym do celów demonstracyjnych. W przypadku obciążeń produkcyjnych należy zintegrować Key Vault z zaufanym urzędem certyfikacji. Zobacz Bezpiecz certyfikaty Azure Key Vault.

package main

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

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

func getClient() *azcertificates.Client {
	keyVaultName := os.Getenv("KEY_VAULT_NAME")
	if keyVaultName == "" {
		log.Fatal("KEY_VAULT_NAME environment variable not set")
	}
	keyVaultUrl := fmt.Sprintf("https://%s.vault.azure.net/", keyVaultName)

	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatal(err)
	}

	return azcertificates.NewClient(keyVaultUrl, cred, nil)
}

func createCert(client *azcertificates.Client) {
	params := azcertificates.CreateCertificateParameters{
		CertificatePolicy: &azcertificates.CertificatePolicy{
			IssuerParameters: &azcertificates.IssuerParameters{
				Name: to.Ptr("Self"),
			},
			X509CertificateProperties: &azcertificates.X509CertificateProperties{
				Subject: to.Ptr("CN=DefaultPolicy"),
			},
		},
	}
	resp, err := client.CreateCertificate(context.TODO(), "myCertName", params, nil)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Requested a new certificate. Operation status: %s\n", *resp.Status)
}

func getCert(client *azcertificates.Client) {
	// an empty string version gets the latest version of the certificate
	version := ""
	getResp, err := client.GetCertificate(context.TODO(), "myCertName", version, nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Enabled set to:", *getResp.Attributes.Enabled)
}

func listCert(client *azcertificates.Client) {
	pager := client.NewListCertificatesPager(nil)
	for pager.More() {
		page, err := pager.NextPage(context.Background())
		if err != nil {
			log.Fatal(err)
		}
		for _, cert := range page.Value {
			fmt.Println(*cert.ID)
		}
	}
}

func updateCert(client *azcertificates.Client) {
	// disables the certificate, sets an expires date, and add a tag
	params := azcertificates.UpdateCertificateParameters{
		CertificateAttributes: &azcertificates.CertificateAttributes{
			Enabled: to.Ptr(false),
			Expires: to.Ptr(time.Now().Add(72 * time.Hour)),
		},
		Tags: map[string]*string{"Owner": to.Ptr("SRE")},
	}
	// an empty string version updates the latest version of the certificate
	version := ""
	_, err := client.UpdateCertificate(context.TODO(), "myCertName", version, params, nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Updated certificate properites: Enabled=false, Expires=72h, Tags=SRE")
}

func deleteCert(client *azcertificates.Client) {
	// DeleteCertificate returns when Key Vault has begun deleting the certificate. That can take several
	// seconds to complete, so it may be necessary to wait before performing other operations on the
	// deleted certificate.
	resp, err := client.DeleteCertificate(context.TODO(), "myCertName", nil)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Deleted certificate with ID: ", *resp.ID)
}

func main() {
	fmt.Println("Authenticating...")
	client := getClient()

	fmt.Println("Creating a certificate...")
	createCert(client)

	fmt.Println("Getting certificate Enabled property ...")
	getCert(client)

	fmt.Println("Listing certificates...")
	listCert(client)

	fmt.Println("Updating a certificate...")
	updateCert(client)

	fmt.Println("Deleting a certificate...")
	deleteCert(client)
}

Uruchamianie kodu

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

export KEY_VAULT_NAME=<vault-name>

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

go run main.go

Przykłady kodu

Aby uzyskać więcej przykładów, zobacz dokumentację 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 "myResourceGroup"

Dalsze kroki

  • Last updated on