Implantar um modelo do Azure Resource Manager usando o SDK do Azure para Go

Neste tutorial, você usará o SDK do Azure para Go para implantar um modelo do Azure Resource Manager.

O Azure Resource Manager é p serviço de implantação e gerenciamento do Azure. Ele permite que você crie, atualize e exclua recursos em sua conta do Azure. Os modelos do Azure Resource Manager descrevem declarativamente sua infraestrutura como código em documentos JSON.

Ao final deste tutorial, você escreve e implanta um modelo do Azure Resource Manager usando o Go.

Pré-requisitos

  • Assinatura do Azure: Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

Criar um novo módulo

Nesta seção, você criará um novo módulo Go e instalará os pacotes necessários do SDK do Azure. Em seguida, você cria o arquivo de aplicativo principal e adiciona um código que implanta um modelo do Azure Resource Manager.

  1. Crie um novo diretório chamado deployARM-how-to. Em seguida, mude para esse diretório.

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

  2. Execute o comando go mod init para criar o arquivo go.mod e os arquivos go.sum.

    go mod init deployARM-how-to

  3. O SDK do Azure para Go contém vários pacotes para trabalhar com o Azure. Para este tutorial, você precisa dos pacotes azcore/to, azidentity e armresources.

    Execute o go get comando para baixar estes pacotes:

    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. Crie um arquivo chamado main.go.

    touch main.go

  5. Abra main.go em seu editor e adicione o seguinte código que se autentica no Azure, cria um grupo de recursos e implanta um modelo do 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)
}

Criar o modelo do Azure Resource Manager

  1. deployARM-how-to No diretório, crie outro arquivo chamado template.json.

  2. Abra o template.json arquivo e adicione o seguinte código de modelo do Azure Resource Manager que cria uma conta de armazenamento do Azure:

    {
    "$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. Substitua <StorageAccountName> e <StorageAccountDisplayName> por um valor de nome de armazenamento válido.

Para obter mais informações sobre modelos do Azure Resource Manager, consulte a visão geral dos modelos do Azure Resource Manager.

Entrar no Azure

O código neste artigo usa o tipo DefaultAzureCredential do módulo de Identidade do Azure para Go para autenticar no Azure. DefaultAzureCredential dá suporte a muitos tipos de credencial para autenticação com o Azure usando o OAuth com a ID do Microsoft Entra. Neste artigo, você usa as credenciais de usuário com as quais entra na CLI do Azure.

Se você ainda não fez isso, entre na CLI do Azure:

az login

Se várias assinaturas estiverem associadas à sua conta, use o comando az account list para obter uma lista dessas assinaturas. Use o comando az account set para definir a assinatura ativa. Ao definir a assinatura ativa, você garante que todos os comandos da CLI executados no restante deste artigo são executados na assinatura pretendida.

Observação

Quando executado localmente, DefaultAzureCredential também dá suporte a credenciais de autenticação da CLI do Desenvolvedor do Azure (AZD) ou a um principal de serviço do Azure que você configura em variáveis de ambiente. Para saber mais sobre todos os tipos de credencial com suporte, consulte a autenticação do Azure com o módulo identidade do Azure para Go.

Executar o aplicativo

Antes de implantar o modelo, você precisa definir sua ID de assinatura do Azure como uma variável de ambiente.

  1. Para obter a ID da assinatura, execute o comando az account show a seguir.

    az account show --query id --output tsv

  2. Defina a variável de AZURE_SUBSCRIPTION_ID ambiente com a ID da assinatura. Substitua <AzureSubscriptionId> por sua ID da assinatura.

    export AZURE_SUBSCRIPTION_ID=<AzureSubscriptionId>

  3. Execute o go run comando para implantar o modelo:

    go run main.go

Troubleshoot

Se a implantação da conta de armazenamento falhar, verifique se você usou um valor de nome de armazenamento válido. Os nomes da conta de armazenamento precisam ter entre 3 e 24 caracteres e podem conter apenas números e letras minúsculas.

Se o programa retornar um erro relacionado à autenticação ou autorização, verifique os seguintes itens:

  • Se o erro começar com um carimbo de data/hora e o seguinte texto: "falha ao obter uma resposta: DefaultAzureCredential: falha ao adquirir um token.", verifique se você efetuou login na CLI do Azure como instruído antes.

  • Se o erro for uma autorização ou erro proibido (código de status 401 ou 403), verifique se sua conta de usuário está em uma função do Azure que lhe dá direitos para criar grupos de recursos e adicionar recursos em sua assinatura. Exemplos incluem as funções padrão Colaborador ou Proprietário no Azure. Para saber como atribuir funções do Azure ao usuário, consulte Atribuir funções do Azure usando a CLI do Azure.

Para obter diretrizes de solução de problemas mais detalhadas, consulte Solucionar problemas de autenticação de Identidade do Azure.

Verificar os recursos no Azure

Você pode usar vários comandos da CLI do Azure para verificar se os recursos foram criados com êxito no Azure. Os comandos a seguir são alguns exemplos.

Para verificar se o grupo de recursos existe, execute o comando az group exists .

az group exists --name deployARM-how-to

Você pode listar os recursos no grupo usando o comando az resource list .

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

Você pode examinar os resultados da implantação (outputResources) e as propriedades usando o comando az deployment group show .

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

Limpar os recursos

Os recursos no Azure podem incorrer em encargos contínuos. Certifique-se de limpar os recursos que você criou neste artigo.

Implantar um modelo vazio no modo completo exclui todos os recursos em um grupo de recursos. É uma forma eficiente de gerenciar os recursos sem excluir o próprio grupo de recursos.

  1. Crie um novo modelo vazio chamado empty-template.json.

  2. Abra empty-template.json no editor e adicione o seguinte código:

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

  3. Abra o arquivo main.go.

  4. Atualize o valor da templateFile constante para empty-template.json.

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

  5. Altere o tempo de implantação de incremental para concluído alterando as propriedades do modo de implantação para DeploymentModeComplete. Para saber mais sobre os modos de implantação, consulte os modos de implantação do 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. Execute o go run comando para implantar o modelo vazio e excluir a conta de armazenamento que você criou anteriormente.

    go run main.go

Em vez de usar uma implantação, você pode excluir o grupo de recursos e todos os seus recursos executando o seguinte comando da CLI do Azure:

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

Próximas etapas

Conceitos Básicos do SDK do Azure para Go

Bibliotecas de gerenciamento do SDK do Azure para Go

  • Última atualização em