Implementación de una plantilla de Azure Resource Manager mediante el SDK de Azure para Go

En este tutorial, usará el SDK de Azure para Go para implementar una plantilla de Azure Resource Manager.

Azure Resource Manager es el servicio de implementación y administración para Azure. Permite crear, actualizar y eliminar recursos en su cuenta de Azure. Las plantillas de Azure Resource Manager describen mediante declaración la infraestructura como código en documentos JSON.

Al final de este tutorial, escribirá e implementará una plantilla de Azure Resource Manager mediante Go.

Prerrequisitos

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

Creación de un nuevo módulo

En esta sección, creará un nuevo módulo de Go e instalará los paquetes necesarios del SDK de Azure. A continuación, cree el archivo de aplicación principal y agregue código que implemente una plantilla de Azure Resource Manager.

  1. Cree un directorio denominado deployARM-how-to. A continuación, cambie a ese directorio.

    mkdir deployARM-how-to
cd deployARM-how-to

  2. Ejecute el go mod init comando para crear los go.mod archivos y go.sum .

    go mod init deployARM-how-to

  3. El SDK de Azure para Go contiene varios paquetes para trabajar con Azure. Para este tutorial, necesita los azcore/topaquetes , azidentityy armresources .

    Ejecute el go get comando para descargar estos paquetes:

    go get github.com/Azure/azure-sdk-for-go/sdk/azcore/to
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity
go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources

  4. Cree un archivo llamado main.go.

    touch main.go

  5. Abra main.go en el editor y agregue el código siguiente que se autentica en Azure, cree un grupo de recursos e implemente una plantilla de Azure Resource Manager:

    package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"os"

	"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/resourcemanager/resources/armresources"
)

const (
	resourceGroupName     = "deployARM-how-to"
	resourceGroupLocation = "eastus"
	deploymentName        = "deployARM-how-to"
	templateFile          = "template.json"
)

var (
	ctx = context.Background()
)

// Read a JSON file from the given path.

func readJSON(path string) (map[string]interface{}, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		log.Fatalf("failed to read file: %v", err)
	}
	contents := make(map[string]interface{})
	_ = json.Unmarshal(data, &contents)
	return contents, nil
}

func main() {
	subscriptionId := os.Getenv("AZURE_SUBSCRIPTION_ID")

	// Authenticate to Azure

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

 	// Create a resource group.

	client, err := armresources.NewResourceGroupsClient(subscriptionId, cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	resp, err := client.CreateOrUpdate(context.Background(), resourceGroupName, armresources.ResourceGroup{
		Location: to.Ptr(resourceGroupLocation),
	}, nil)
	if err != nil {
		log.Fatalf("failed to obtain a response: %v", err)
	}
	log.Printf("resource group ID: %s\n", *resp.ResourceGroup.ID)

	// Read the template file.

	template, err := readJSON(templateFile)
	if err != nil {
		return
	}

	// Deploy the Azure Resource Manager template.

	deploymentsClient, err := armresources.NewDeploymentsClient(subscriptionId, cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	deploy, err := deploymentsClient.BeginCreateOrUpdate(
		ctx,
		resourceGroupName,
		deploymentName,
		armresources.Deployment{
			Properties: &armresources.DeploymentProperties{
				Template: template,
				Mode:     to.Ptr(armresources.DeploymentModeIncremental),
			},
		},
		nil,
	)
	if err != nil {
		log.Fatalf("failed to deploy template: %v", err)
	}

	fmt.Println(deploy)
}

Creación de la plantilla de Azure Resource Manager

  1. En el deployARM-how-to directorio , cree otro archivo denominado template.json.

  2. Abra el archivo y agregue el template.json siguiente código de plantilla de Azure Resource Manager que crea una cuenta de Azure Storage:

    {
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
    },
    "functions": [],
    "variables": {},
    "resources": [{
        "name": "<StorageAccountName>",
        "type": "Microsoft.Storage/storageAccounts",
        "apiVersion": "2021-04-01",
        "tags": {
            "displayName": "<StorageAccountDisplayName>"
        },
        "location": "EastUS",
        "kind": "StorageV2",
        "sku": {
            "name": "Premium_LRS",
            "tier": "Premium"
        }
    }],
    "outputs": {}
}

  3. Reemplace <StorageAccountName> y <StorageAccountDisplayName> por un valor de nombre de almacenamiento válido.

Para más información sobre las plantillas de Azure Resource Manager, consulte Introducción a las plantillas de Azure Resource Manager.

Inicio de sesión en Azure

El código de este artículo usa el tipo DefaultAzureCredential del módulo Azure Identity para Go para autenticarse en Azure. DefaultAzureCredential admite muchos tipos de credenciales para la autenticación con Azure mediante OAuth con el identificador de Microsoft Entra. En este artículo, usará las credenciales de usuario con las que inicia sesión en la CLI de Azure.

Si aún no lo ha hecho, inicie sesión en la CLI de Azure:

az login

Si hay varias suscripciones asociadas a su cuenta, use el comando az account list para obtener una lista de esas suscripciones. Use el comando az account set para establecer la suscripción activa. Al establecer la suscripción activa, asegúrese de que los comandos de la CLI que ejecute en el resto de este artículo se ejecuten en la suscripción prevista.

Nota:

Cuando se ejecuta localmente, DefaultAzureCredential también admite las credenciales de inicio de sesión de Azure Developer CLI (AZD) o un service principal de Azure que configures en las variables de entorno. Para más información sobre todos los tipos de credenciales admitidos, consulte Autenticación de Azure con el módulo Azure Identity para Go.

Ejecutar la aplicación

Para poder implementar la plantilla, debe definir el identificador de suscripción de Azure como una variable de entorno.

  1. Para obtener el identificador de suscripción, ejecute el siguiente comando az account show .

    az account show --query id --output tsv

  2. Configure la variable de entorno AZURE_SUBSCRIPTION_ID con su ID de suscripción. Reemplace <AzureSubscriptionId> con el Id. de suscripción.

    export AZURE_SUBSCRIPTION_ID=<AzureSubscriptionId>

  3. Ejecute el go run comando para implementar la plantilla:

    go run main.go

Troubleshoot

Si se produce un error en la implementación de la cuenta de almacenamiento, compruebe que usó un valor de nombre de almacenamiento válido. Los nombres de las cuentas de almacenamiento deben tener entre 3 y 24 caracteres y solo pueden incluir números y letras en minúscula.

Si el programa devuelve un error relacionado con la autenticación o autorización, compruebe los siguientes elementos:

  • Si el error comienza con una marca de tiempo y el texto siguiente: "no se pudo obtener una respuesta: DefaultAzureCredential: no se pudo adquirir un token", asegúrese de que inició sesión en la CLI de Azure como se indicó anteriormente.

  • Si el error es un error de autorización o prohibido (código de estado 401 o 403), asegúrese de que la cuenta de usuario está en un rol de Azure que le concede derechos para crear grupos de recursos y agregar recursos en la suscripción. Entre los ejemplos se incluyen los roles integrados colaborador o propietariode Azure. Para obtener información sobre cómo asignar roles de Azure al usuario, consulte Asignación de roles de Azure mediante la CLI de Azure.

Para obtener instrucciones de solución de problemas más detalladas, consulte Solución de problemas de autenticación de identidad de Azure.

Comprobación de los recursos en Azure

Puede usar varios comandos de la CLI de Azure para comprobar que los recursos se crearon correctamente en Azure. Los siguientes comandos son algunos ejemplos.

Para comprobar que el grupo de recursos existe, ejecute el comando az group exists .

az group exists --name deployARM-how-to

Puede enumerar los recursos del grupo mediante el comando az resource list .

az resource list --resource-group deployARM-how-to

Puede examinar los resultados de la implementación (recursos de salida) y las propiedades mediante el comando az deployment group show.

az deployment group show -g deployARM-how-to -n deployARM-how-to

Limpieza de recursos

Los recursos de Azure pueden incurrir en cargos continuos. Asegúrese de limpiar los recursos que creó en este artículo.

La implementación de una plantilla vacía en modo completo elimina todos los recursos de un grupo de recursos. Es una manera ordenada de limpiar los recursos sin eliminar el propio grupo de recursos.

  1. Cree una plantilla vacía denominada empty-template.json.

  2. Abra empty-template.json en el editor y agregue el código siguiente:

    {
    "$schema": "https://schema.management.azure.com/schemas/2019-08-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {},
    "variables": {},
    "resources": [],
    "outputs": {}
}

  3. Abrir el archivo main.go.

  4. Actualice el templateFile valor constante a empty-template.json.

    const (
	resourceGroupName     = "deployARM-how-to"
	resourceGroupLocation = "eastus"
	deploymentName        = "deployARM-how-to"
	templateFile          = "empty-template.json"
)

  5. Cambie el tiempo de implementación de incremental a completado cambiando las propiedades del modo de implementación a DeploymentModeComplete. Para más información sobre los modos de implementación, consulte modos de implementación de Azure Resource Manager.

    deploy, err = deploymentsClient.BeginCreateOrUpdate(
	ctx,
	resourceGroupName,
	deploymentName,
	armresources.Deployment{
		Properties: &armresources.DeploymentProperties{
			Template: template,
			Mode:     to.Ptr(armresources.DeploymentModeComplete), //Deployment Mode is here
		},
	},
	nil,
)

  6. Ejecute el go run comando para implementar la plantilla vacía y eliminar la cuenta de almacenamiento que creó anteriormente.

    go run main.go

En lugar de usar una implementación, puede eliminar el grupo de recursos y todos sus recursos mediante la ejecución del siguiente comando de la CLI de Azure:

az group delete --resource-group deployARM-how-to

Pasos siguientes

Conceptos básicos del SDK de Azure para Go

Bibliotecas de administración de Azure SDK para Go

  • Se actualizó por última vez el