Autenticación con Azure SDK para Go mediante una identidad administrada

  • Artículo

En este tutorial, configurará una máquina virtual de Azure con una identidad administrada para autenticarse en Azure mediante el SDK de Azure para Go.

Las identidades administradas permiten que no tenga que administrar las credenciales, ya que proporcionan una identidad para el recurso de Azure. Los permisos asignados a la identidad conceden al recurso acceso a otros recursos de Azure que admiten identidades administradas. Eliminación de la necesidad de pasar credenciales a la aplicación.

Siga este tutorial para asignar una identidad administrada a una máquina virtual y autenticarse en Azure mediante una identidad administrada.

Requisitos previos

  • Suscripción de Azure: si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

1. Configurar su entorno

Antes de comenzar, deberá configurar el entorno.

Implementación de una máquina virtual

Implemente una máquina virtual en Azure. Ejecutará el código de Go para crear un secreto en Azure Key Vault desde esa máquina virtual.

  1. Cree un grupo de recursos de Azure.

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

    Cambie el parámetro --location al valor adecuado para su entorno.

  2. Cree la máquina virtual de 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>

    Reemplace <password> por su contraseña.

Para más información sobre otros servicios que admiten identidades administradas, consulte Servicios que admiten identidades administradas para recursos de Azure.

Implementación de una instancia de Key Vault

Para crear una nueva instancia de Azure Key Vault ejecute el comando siguiente:

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

Reemplace <keyVaultName> por un nombre único global.

2. Creación de una entidad administrada

Azure admite dos tipos de identidades administradas: las asignadas por el sistema y las asignadas por el usuario.

Las identidades asignadas por el sistema se asocian directamente a un recurso de Azure y se limitan únicamente a ese recurso. Las identidades asignadas por el usuario son recursos independientes que se pueden asignar a uno o varios recursos de Azure.

Para más información sobre la diferencia entre las identidades asignadas por el sistema y las asignadas por el usuario, consulte Tipos de identidad administrada.

Elija una de las siguientes opciones:

Opción 1: Crear una identidad administrada asignada por el sistema

Ejecute los siguientes comandos para crear una identidad asignada por el sistema:

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

Opción 2: Crear una identidad administrada asignada por el usuario

Ejecute los siguientes comandos para crear una identidad administrada asignada por el usuario:

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

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

Reemplace <UserIdentityId> por el identificador de la identidad administrada asignada por el usuario.

Para más información, consulte Configuración de identidades administradas para recursos de Azure en una VM de Azure mediante la CLI de Azure.

3. Asignación de un rol a la identidad administrada

Después de crear una identidad administrada, asigne roles para conceder los permisos de identidad para acceder a otro recurso de Azure. En este tutorial, asignará el rol integrado de Key Vault Contributor a la identidad administrada para que la aplicación Go pueda crear un secreto dentro de la instancia de Key Vault.

Elija una de las siguientes opciones:

Opción 1: Asignar un rol a una identidad asignada por el sistema

Ejecute los siguientes comandos para asignar el rol Key Vault Contributor a la identidad administrada asignada por el sistema:

#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>'

Opción 2: Asignar un rol a una identidad asignada por el usuario

Ejecute los comandos siguientes para asignar el rol Key Vault Contributor a la identidad administrada asignada por el usuario:

#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>'

Para más información sobre los roles integrados, consulte Roles integrados de Azure.

4. Creación de un secreto de almacén de claves con Go

A continuación, inicie sesión mediante SSH en la máquina virtual de Azure, instale Go y cree el paquete de Go.

Instalación de Go en la máquina virtual de Azure

  1. Obtenga la dirección IP pública de la máquina virtual de Azure.

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

  2. Conéctese mediante SSH a la máquina virtual de Azure.

    ssh azureuser@<public-ip>

    Reemplace <public-ip> por la dirección IP pública de la máquina virtual de Azure.

  3. Instalación de Go

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

Creación del paquete de Go

  1. Cree un nuevo directorio con el nombre go-on-azure en el directorio principal.

    mkidr ~/go-on-azure

  2. Cambie al directorio go-on-azure.

    cd ~/go-on-azure

  3. Ejecute go mod init para crear el archivo go.mod.

    go mod init go-on-azure

  4. Ejecute go get para instalar los módulos de Go necesarios.

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

  5. Cree un archivo main.go y copie el siguiente código en él.

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

Antes de ejecutar el código, cree una variable de entorno llamada KEY_VAULT_NAME. Establezca el valor de la variable de entorno en el nombre de la instancia de Azure Key Vault que creó previamente. Reemplace por <KeyVaultName> el nombre de la instancia de Azure Key Vault.

export KEY_VAULT_NAME=<KeyVaultName>

A continuación, ejecute el go run comando para crear un secreto del almacén de claves.

go run main.go

Compruebe que el secreto del almacén de claves se creó con Azure PowerShell, la CLI de Azure o Azure Portal.

Pasos siguientes

Obtenga más información sobre el uso de Azure SDK para Go