Implemente um modelo Azure Resource Manager usando o Azure SDK for Go

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

O Azure Resource Manager é o serviço de implementação e gestão 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.

No final deste tutorial, escreves e implementas 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.

Go versão 1.18 ou superior
Azure CLI

Criar um novo módulo

Nesta secção, cria um novo módulo Go e instala os pacotes necessários do Azure SDK. Depois crias o ficheiro principal da aplicação e adicionas código que implementa um template do Azure Resource Manager.

Crie um novo diretório chamado deployARM-how-to. Em seguida, mude para esse diretório.
```
mkdir deployARM-how-to
cd deployARM-how-to
```
Execute o go mod init comando para criar os go.mod arquivos e go.sum .
```
go mod init deployARM-how-to
```

O Azure SDK for Go contém vários pacotes para trabalhar com Azure. Para este tutorial, precisas 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

Crie um ficheiro com o nome main.go.
```
touch main.go
```

Abre main.go no teu editor e adiciona o seguinte código que autentica no Azure, cria um grupo de recursos e implementa um modelo 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

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

Abra o template.json ficheiro e adicione o seguinte código modelo do Azure Resource Manager que cria uma conta de armazenamento 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": {}
}

Substitua <StorageAccountName> e <StorageAccountDisplayName> por um valor de nome de armazenamento válido.

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

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

Se ainda não o fez, inicie sessão na CLI do Azure:

az login

Se houver várias subscrições associadas à sua conta, use o comando lista de contas do Arizona para obter uma lista dessas subscrições. Use o comando az account set para definir a subscrição ativa. Ao definir a subscrição ativa, garante que quaisquer comandos CLI que execute no resto deste artigo correm contra a subscrição pretendida.

Observação

Quando executado localmente, DefaultAzureCredential também suporta credenciais de login da Azure Developer CLI (AZD) ou um principal de serviço da Azure que você configura em variáveis de ambiente. Para saber mais sobre todos os tipos de credenciais suportados, consulte Autenticação do Azure com o módulo Azure Identity for Go.

Execute o aplicativo

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

Para obter o ID da subscrição, execute o seguinte comando mostrar conta az .
```
az account show --query id --output tsv
```
Defina a AZURE_SUBSCRIPTION_ID variável de ambiente com o seu ID de subscrição. Substitua <AzureSubscriptionId> pelo seu ID de subscrição.
```
export AZURE_SUBSCRIPTION_ID=<AzureSubscriptionId>
```
Execute o go run comando para implementar o modelo:
```
go run main.go
```

Troubleshoot

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

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

Caso o erro comece com um carimbo de data/hora e o seguinte texto: "falha ao obter uma resposta: DefaultAzureCredential: falha ao adquirir um token.", certifique-se de ter iniciado sessão na CLI do Azure como explicado anteriormente.
Se o erro for uma autorização ou um erro proibido (código de estado 401 ou 403), certifique-se de que a sua conta de utilizador está numa função do Azure que lhe concede direitos para criar grupos de recursos e adicionar recursos à sua subscrição. Exemplos são os funcionalidades incorporadas do Azure como Proprietário ou Colaborador. Para saber como atribuir funções do Azure ao seu usuário, consulte Atribuir funções do Azure usando a CLI do Azure.

Para obter orientações de solução de problemas mais detalhadas, consulte Solucionar problemas de autenticação do Azure Identity.

Verificar os recursos no Azure

Pode usar vários comandos do Azure CLI para verificar se os recursos foram criados com sucesso no Azure. Os comandos a seguir são alguns exemplos.

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

az group exists --name deployARM-how-to

Podes listar os recursos no grupo usando o comando az resource list .

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

Pode analisar os resultados de implementação (outputResources) e propriedades usando o comando az deployment group show.

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

Limpeza de recursos

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

A implantação de um modelo vazio no modo completo exclui todos os recursos dentro de um grupo de recursos. É uma maneira interessante de limpar recursos sem eliminar o próprio grupo de recursos.

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

Abra empty-template.json no seu 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": {}
}

Abra o ficheiro main.go.

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

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

Mude o tempo de implementação de incremental para completo alterando as propriedades do Modo de implementação para DeploymentModeComplete. Para saber mais sobre os modos de implantação, consulte 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,
)

Execute o go run comando para implantar o modelo vazio e excluir a conta de armazenamento criada anteriormente.
```
go run main.go
```

Em vez de usar uma implementação, pode eliminar o grupo de recursos e todos os seus recursos executando o seguinte comando Azure CLI:

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

Próximos passos

Conceitos principais do SDK do Azure para Go

Bibliotecas de gerenciamento do SDK do Azure para Go

Comentários

Esta página foi útil?

Última atualização a 2025-12-17