Megosztás a következőn keresztül:

Rövid útmutató: Azure Key Vault-tanúsítvány ügyfélkódtár a Go-hoz

  • Cikk

Ebben a rövid útmutatóban megtanulhatja, hogyan kezelheti a tanúsítványokat az Azure Key Vaultban az Azure SDK for Go használatával.

Az Azure Key Vault egy felhőszolgáltatás, amely biztonságos titkoskulcs-tárolóként működik. Biztonságosan tárolhatja kulcsait, jelszavait, tanúsítványait és egyéb titkos adatait. A Key Vaulttal kapcsolatos további információt az Áttekintés szakaszban talál.

Ebből az útmutatóból megtudhatja, hogyan kezelheti Azure Key Vault-tanúsítványait az Azcertificates-csomag használatával a Go használatával.

Előfeltételek

Jelentkezzen be az Azure Portalra

  1. Az Azure CLI-ben futtassa a következő parancsot:

    az login

    Ha az Azure CLI meg tudja nyitni az alapértelmezett böngészőt, ezt az Azure Portal bejelentkezési oldalán teheti meg.

    Ha a lap nem nyílik meg automatikusan, lépjen a lapra https://aka.ms/devicelogin, majd adja meg a terminálban megjelenő engedélyezési kódot.

  2. Jelentkezzen be az Azure Portalra a fiók hitelesítő adataival.

Erőforráscsoport és kulcstartó létrehozása

Ez a rövid útmutató egy előre létrehozott Azure Key Vaultot használ. Kulcstartót az Azure CLI rövid útmutatójában, az Azure PowerShell gyorsútmutatójában vagy az Azure Portal rövid útmutatójában ismertetett lépések követésével hozhat létre.

Másik lehetőségként futtathatja ezeket az Azure CLI- vagy Azure PowerShell-parancsokat.

Fontos

Minden kulcstartónak egyedi névvel kell rendelkeznie. Cserélje le <az egyedi-keyvault-nevét> a kulcstartó nevére az alábbi példákban.

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

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

Hozzáférés biztosítása a kulcstartóhoz

Ha szerepköralapú hozzáférés-vezérléssel (RBAC) szeretne engedélyeket szerezni a kulcstartóhoz, rendeljen hozzá egy szerepkört a "Felhasználónév" (UPN) szolgáltatáshoz az Az role Assignment Create Azure CLI-paranccsal.

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

Cserélje le <a upn>, <subscription-id>, <resource-group-name> és <your-unique-keyvault-name> értékét a tényleges értékekre. Az UPN általában egy e-mail-cím (pl. username@domain.com) formátumban lesz.

Új Go-modul létrehozása és csomagok telepítése

Futtassa a következő Go-parancsokat:

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

A mintakód létrehozása

Hozzon létre egy elnevezett main.go fájlt, és másolja a következő kódot a fájlba:

package main

import (
	"context"
	"fmt"
	"log"
	"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)
}

A kód futtatása

A kód futtatása előtt hozzon létre egy környezeti változót .KEY_VAULT_NAME Állítsa a környezeti változó értékét a korábban létrehozott Azure Key Vault nevére.

export KEY_VAULT_NAME=<YourKeyVaultName>

Ezután futtassa a következő go run parancsot az alkalmazás futtatásához:

go run main.go

Kódpéldák

További példákért tekintse meg a modul dokumentációját .

Az erőforrások eltávolítása

Futtassa a következő parancsot az erőforráscsoport és az összes többi erőforrás törléséhez:

az group delete --resource-group myResourceGroup

Következő lépések