Uwierzytelnianie za pomocą zestawu Azure SDK dla języka Go przy użyciu tożsamości zarządzanej

  • Artykuł

W tym samouczku skonfigurujesz maszynę wirtualną platformy Azure z tożsamością zarządzaną w celu uwierzytelniania na platformie Azure przy użyciu zestawu Azure SDK dla języka Go.

Tożsamości zarządzane eliminują konieczność zarządzania poświadczeniami, zapewniając tożsamość bezpośrednio do zasobu platformy Azure. Uprawnienia przypisane do tożsamości zapewniają dostęp do zasobów innych zasobów platformy Azure, które obsługują tożsamości zarządzane. Usunięcie konieczności przekazania poświadczeń do aplikacji.

Postępuj zgodnie z tym samouczkiem, aby przypisać tożsamość zarządzaną do maszyny wirtualnej i uwierzytelnić się na platformie Azure przy użyciu tożsamości zarządzanej.

Wymagania wstępne

  • Subskrypcja platformy Azure: jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.
  • Zainstalowany program Go: wersja 1.18 lub nowsza

1. Konfigurowanie środowiska

Przed rozpoczęciem należy skonfigurować środowisko.

Wdrażanie maszyny wirtualnej

Wdrażanie maszyny wirtualnej na platformie Azure. Uruchomisz kod Języka Go, aby utworzyć wpis tajny w usłudze Azure Key Vault z tej maszyny wirtualnej.

  1. Utwórz grupę zasobów platformy Azure.

    az group create --name go-on-azure --location eastus

    Zmień parametr na --location odpowiednią wartość dla danego środowiska.

  2. Utwórz maszynę wirtualną platformy Azure.

    az vm create \
--resource-group go-on-azure \
--name go-on-azure-vm \
--image canonical:ubuntuserver:19.04:latest \
--admin-username azureuser \
--admin-password <password>

    Zastąp <password> hasło.

Aby dowiedzieć się więcej o innych usługach obsługujących tożsamości zarządzane, zobacz Usługi obsługujące tożsamości zarządzane dla zasobów platformy Azure.

Wdrażanie wystąpienia magazynu kluczy

Utwórz nowe wystąpienie usługi Azure Key Vault, uruchamiając następujące polecenie:

az keyvault create --location eastus --name `<keyVaultName>` --resource-group go-on-azure

Zastąp <keyVaultName> ciąg globalnie unikatową nazwą.

2. Tworzenie tożsamości zarządzanej

Na platformie Azure są obsługiwane dwa typy tożsamości zarządzanych; przypisane przez system i przypisane przez użytkownika.

Tożsamości przypisane przez system są bezpośrednio dołączone do zasobu platformy Azure i ograniczone tylko do tego zasobu. Tożsamości przypisane przez użytkownika są zasobami autonomicznymi, które można przypisać do co najmniej jednego zasobu platformy Azure.

Aby dowiedzieć się więcej o różnicy między przypisanymi przez system i przypisanymi przez użytkownika, zobacz Typy tożsamości zarządzanych.

Wybierz jedną z następujących opcji:

Opcja 1. Tworzenie tożsamości przypisanej przez system

Uruchom następujące polecenia, aby utworzyć tożsamość zarządzaną przypisaną przez system:

az vm identity assign -g go-on-azure -n go-on-azure-vm

Opcja 2. Tworzenie tożsamości przypisanej przez użytkownika

Uruchom następujące polecenia, aby utworzyć tożsamość zarządzaną przypisaną przez użytkownika:

az identity create -g go-on-azure -n GoUserIdentity

az vm identity assign -g go-on-azure -n go-on-azure-vm --identities <UserIdentityId>

Zastąp element <UserIdentityId> identyfikatorem tożsamości użytkownika zarządzanego.

Aby dowiedzieć się więcej, zobacz Konfigurowanie tożsamości zarządzanych dla zasobów platformy Azure na maszynie wirtualnej platformy Azure przy użyciu interfejsu wiersza polecenia platformy Azure.

3. Przypisywanie roli do tożsamości zarządzanej

Po utworzeniu tożsamości zarządzanej przypiszesz role, aby przyznać tożsamości uprawnienia dostępu do innego zasobu platformy Azure. W tym samouczku przypiszesz wbudowaną rolę Key Vault Contributor tożsamości zarządzanej, aby aplikacja Go mogła utworzyć wpis tajny w wystąpieniu magazynu kluczy.

Wybierz jedną z następujących opcji:

Opcja 1. Przypisywanie roli do tożsamości przypisanej przez system

Uruchom następujące polecenia, aby przypisać Key Vault Contributor rolę do przypisanej przez system tożsamości zarządzanej:

#output system identity principal ID
az vm identity show --name go-on-azure-vm --resource-group go-on-azure --query 'principalId' -o tsv

#output key vault ID
scope=$(az keyvault show --name go-on-azure-kv --query id -o tsv)

az role assignment create --assignee '<principalId>' --role 'Key Vault Contributor' --scope '<keyVaultId>'

Opcja 2. Przypisywanie roli do tożsamości przypisanej przez użytkownika

Uruchom następujące polecenia, aby przypisać Key Vault Contributor rolę do tożsamości zarządzanej przypisanej przez użytkownika:

#output user identity principal ID
az identity show --resource-group go-on-azure --name GoUserIdentity --query 'principalId' -o tsv

#output key vault ID
az keyvault show --name go-on-azure-kv --query id -o tsv

az role assignment create --assignee '<principalId>' --role 'Key Vault Contributor' --scope '<keyVaultId>'

Aby dowiedzieć się więcej o rolach wbudowanych, zapoznaj się z wbudowanymi rolami platformy Azure.

4. Tworzenie wpisu tajnego magazynu kluczy za pomocą języka Go

Następnie za pomocą protokołu SSH na maszynie wirtualnej platformy Azure zainstaluj język Go i skompiluj pakiet Go.

Instalowanie języka Go na maszynie wirtualnej platformy Azure

  1. Uzyskaj publiczny adres IP maszyny wirtualnej platformy Azure.

    az vm show -d -g go-on-azure -n go-on-azure-vm --query publicIps -o tsv

  2. Połączenie SSH z maszyną wirtualną platformy Azure.

    ssh azureuser@<public-ip>

    Zastąp <public-ip> ciąg publicznym adresem IP maszyny wirtualnej platformy Azure.

  3. Instalowanie języka Go

    sudo add-apt-repository ppa:longsleep/golang-backports;
sudo apt update;
sudo apt install golang-go -y

Tworzenie pakietu Języka Go

  1. Utwórz nowy katalog o nazwie go-on-azure w katalogu głównym.

    mkidr ~/go-on-azure

  2. Przejdź do go-on-azure katalogu.

    cd ~/go-on-azure

  3. Uruchom polecenie go mod init , aby utworzyć go.mod plik.

    go mod init go-on-azure

  4. Uruchom polecenie go get , aby zainstalować wymagane moduły języka Go.

    go get "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
go get "github.com/Azure/azure-sdk-for-go/sdk/keyvault/azsecrets"

  5. main.go Utwórz plik i skopiuj do niego następujący kod.

    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 createSecret() {
    keyVaultName := os.Getenv("KEY_VAULT_NAME")
    secretName := "quickstart-secret"
    secretValue := "createdWithGO"
    keyVaultUrl := fmt.Sprintf("https://%s.vault.azure.net/", keyVaultName)

    cred, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        log.Fatalf("failed to obtain a credential: %v", err)
    }

    client, err := azsecrets.NewClient(keyVaultUrl, cred, nil)
    if err != nil {
        log.Fatalf("failed to create a client: %v", err)
    }

    resp, err := client.SetSecret(context.TODO(), secretName, secretValue, nil)
    if err != nil {
        log.Fatalf("failed to create a secret: %v", err)
    }

    fmt.Printf("Name: %s, Value: %s\n", *resp.ID, *resp.Value)
}

func main() {
    createSecret()
}

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. Zastąp <KeyVaultName> ciąg nazwą wystąpienia usługi Azure Key Vault.

export KEY_VAULT_NAME=<KeyVaultName>

Następnie uruchom go run polecenie , aby utworzyć wpis tajny magazynu kluczy.

go run main.go

Sprawdź, czy wpis tajny magazynu kluczy został utworzony przy użyciu programu Azure PowerShell, interfejsu wiersza polecenia platformy Azure lub witryny Azure Portal.

Następne kroki

Dowiedz się więcej o korzystaniu z zestawu Azure SDK dla języka Go