Gerenciar grupos de recursos com o SDK do Azure para linguagem Go

Artigo
08/07/2024

Neste artigo, você aprenderá a criar e gerenciar um grupo de recursos com a biblioteca de gerenciamento do SDK do Azure para linguagem Go.

1. Configurar os recursos do Azure

Para concluir as etapas neste artigo, você precisa dos seguintes recursos e identificadores do Azure:

Assinatura do Azure: caso você não tenha uma assinatura do Azure, crie uma conta gratuita antes de começar.
Obtenha a ID da assinatura do Azure.
Obtenha a ID do locatário do Microsoft Entra.
Crie uma entidade de serviço. Observe o segredo e a ID do aplicativo da entidade de serviço (cliente). Certifique-se de seguir também as instruções para atribuir a função de Colaborador em sua assinatura ao aplicativo. A função de Colaborador é uma função de administrador privilegiado que concede permissão para gerenciar todos os recursos em sua assinatura.

Antes de prosseguir para a próxima seção, certifique-se de ter anotado a ID da assinatura (Guid), a ID do locatário (Guid), a ID do cliente/aplicativo (Guid) e o segredo da entidade de serviço.

2. Definir variáveis de ambiente de autenticação

Usando suas informações de autenticação do Azure, defina as variáveis de ambiente apropriadas para que o seu código possa se autenticar no Azure.

Bash
Windows

Defina as variáveis de ambiente a seguir. Substitua os espaços reservados pelos valores adequados da seção anterior.

export AZURE_SUBSCRIPTION_ID="<azure_subscription_id>"
export AZURE_TENANT_ID="<active_directory_tenant_id>"
export AZURE_CLIENT_ID="<service_principal_appid>"
export AZURE_CLIENT_SECRET="<service_principal_password>"

Defina as variáveis de ambiente a seguir. Substitua os espaços reservados pelos valores adequados da seção anterior.

set AZURE_SUBSCRIPTION_ID="<azure_subscription_id>"
set AZURE_TENANT_ID="<active_directory_tenant_id>"
set AZURE_CLIENT_ID="<service_principal_appid>"
set AZURE_CLIENT_SECRET="<service_principal_password>"

3. Criar um grupo de recursos

Crie um diretório para testar e executar o código Go de exemplo e torne ele o diretório atual.
Execute o comando go mod init para criar um módulo no diretório atual.
```
go mod init <module_path>
```
Pontos principais:
- O parâmetro <module_path> geralmente é um local em um repositório do GitHub, tal como github.com/<your_github_account_name>/<directory>.
- Quando você está criando um aplicativo de linha de comando como teste e não vai publicar o aplicativo, o <module_path> não precisa se referir a um local real.
Execute go get para baixar, criar e instalar os módulos do SDK do Azure para linguagem Go necessários.
```
go get github.com/Azure/azure-sdk-for-go/sdk/azcore
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
```
Importante

Os pacotes da versão atual das bibliotecas de gerenciamento de recursos do Azure estão localizados em sdk/**/arm**. Os pacotes da versão anterior das bibliotecas de gerenciamento estão localizados em /services. Se estiver usando a versão anterior, consulte o Guia de migração do SDK do Azure para linguagem Go.

Crie um arquivo chamado main.go e adicione o código a seguir. Cada seção do código é comentada para explicar sua finalidade.

package main

// Import key modules.
import (
	"context"
	"log"
	"os"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
	"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"
)

// Define key global variables.
var (
	subscriptionId    = os.Getenv("AZURE_SUBSCRIPTION_ID")
	location          = "eastus"
	resourceGroupName = "myResourceGroup" // !! IMPORTANT: Change this to a unique name in your subscription.
	ctx               = context.Background()
)

// Define the function to create a resource group.
func createResourceGroup(subscriptionId string, credential azcore.TokenCredential) (armresources.ResourceGroupsClientCreateOrUpdateResponse, error) {
	rgClient, _ := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)

	param := armresources.ResourceGroup{
		Location: to.Ptr(location),
	}

	return rgClient.CreateOrUpdate(ctx, resourceGroupName, param, nil)
}

// Define the standard 'main' function for an app that is called from the command line.
func main() {

	// Create a credentials object.
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("Authentication failure: %+v", err)
	}

	// Call your function to create an Azure resource group.
	resourceGroup, err := createResourceGroup(subscriptionId, cred)
	if err != nil {
		log.Fatalf("Creation of resource group failed: %+v", err)
	}

	// Print the name of the new resource group.
	log.Printf("Resource group %s created", *resourceGroup.ResourceGroup.ID)
}

Pontos principais:

O valor subscriptionId é recuperado da variável de ambiente AZURE_SUBSCRIPTION_ID.
As cadeias de caracteres location e resourceGroupName são definidas como valores de teste. Se necessário, altere esses valores para algo mais apropriado para sua localização e assinatura.

Execute o comando go mod tidy para limpar as dependências no arquivo go.mod com base em seu código-fonte.
```
go mod tidy
```
Execute go run para criar e executar o aplicativo.
```
go run .
```

4. Verificar os resultados

Navegue até o Portal do Azure.
Entre e selecione sua assinatura do Azure.
No menu esquerdo, selecione Grupo de recursos.
O novo grupo de recursos é listado entre os grupos de recursos da sua assinatura do Azure.

Execute az group show para exibir o grupo de recursos.

az group show --name <resource_group>

Execute Get-AzResourceGroup para exibir o grupo de recursos.

Get-AzResourceGroup -Name <resource_group>

5. Atualizar um grupo de recursos

Retorne para o seu arquivo main.go.

Insira o código a seguir logo acima da função main.

// Update the resource group by adding a tag to it.
func updateResourceGroup(subscriptionId string, credential azcore.TokenCredential) (armresources.ResourceGroupsClientUpdateResponse, error) {
    rgClient, _ := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)

    update := armresources.ResourceGroupPatchable{
        Tags: map[string]*string{
            "new": to.Ptr("tag"),
        },
    }
    return rgClient.Update(ctx, resourceGroupName, update, nil)
}

Depois de adicionar o código, vá para a próxima seção. Execute o código em uma seção posterior.

6. Listar os grupos de recursos de uma assinatura do Azure

Retorne para o seu arquivo main.go.

Insira o código a seguir logo acima da função main.

// List all the resource groups of an Azure subscription.
func listResourceGroups(subscriptionId string, credential azcore.TokenCredential) ([]*armresources.ResourceGroup, error) {
    rgClient, _ := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)

    pager := rgClient.NewListPager(nil)

    var resourceGroups []*armresources.ResourceGroup
    for pager.More() {
        resp, err := pager.NextPage(ctx)
        if err != nil {
            return nil, err
        }
        if resp.ResourceGroupListResult.Value != nil {
            resourceGroups = append(resourceGroups, resp.ResourceGroupListResult.Value...)
        }
    }
    return resourceGroups, nil
}

Depois de adicionar o código, vá para a próxima seção. Execute o código em uma seção posterior.

7. Excluir um grupo de recursos

Retorne para o seu arquivo main.go.

Insira o código a seguir logo acima da função main.

// Delete a resource group.
func deleteResourceGroup(subscriptionId string, credential azcore.TokenCredential) error {
    rgClient := armresources.NewResourceGroupsClient(subscriptionId, credential, nil)

    poller, err := rgClient.BeginDelete(ctx, resourceGroupName, nil)
    if err != nil {
        return err
    }
    if _, err := poller.PollUntilDone(ctx, nil); err != nil {
        return err
    }
    return nil
}

Depois de adicionar o código, vá para a próxima seção. Execute o código em uma seção posterior.

8. Atualizar a função principal

Nas seções anteriores, você adicionou código ao main.go para criar, atualizar e excluir um grupo de recursos. Você também adicionou código para listar todos os grupos de recursos em uma assinatura do Azure. Para executar todas essas funções sequencialmente:

Em main.go, substitua a função main pelo código a seguir:

func main() {

    // Create a credentials object.
    cred, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        log.Fatalf("Authentication failure: %+v", err)
    }

    // Call your function to create an Azure resource group.
    resourceGroup, err := createResourceGroup(subscriptionId, cred)
    if err != nil {
        log.Fatalf("Creation of resource group failed: %+v", err)
    }
    // Print the name of the new resource group.
    log.Printf("Resource group %s created", *resourceGroup.ResourceGroup.ID)

    // Call your function to add a tag to your new resource group.
    updatedRG, err := updateResourceGroup(subscriptionId, cred)
    if err != nil {
        log.Fatalf("Update of resource group failed: %+v", err)
    }
    log.Printf("Resource Group %s updated", *updatedRG.ResourceGroup.ID)

    // Call your function to list all the resource groups.
    rgList, err := listResourceGroups(subscriptionId, cred)
    if err != nil {
        log.Fatalf("Listing of resource groups failed: %+v", err)
    }
    log.Printf("Your Azure subscription has a total of %d resource groups", len(rgList))

    // Call your function to delete the resource group you created.
    if err := deleteResourceGroup(subscriptionId, cred); err != nil {
        log.Fatalf("Deletion of resource group failed: %+v", err)
    }
    log.Printf("Resource group deleted")
}

Execute o código e observe a saída.

go run .

2024/07/31 15:29:06 Resource group /subscriptions/<subscription ID>/resourceGroups/myResourceGroup created
2024/07/31 15:29:07 Resource Group /subscriptions/<subscription ID>/resourceGroups/myResourceGroup updated
2024/07/31 15:29:07 Your Azure subscription has a total of 8 resource groups
2024/07/31 15:30:25 Resource group deleted

Observação

A exclusão do grupo de recursos pode levar alguns minutos.

Solução de problemas

Verifique as perguntas anteriores postadas no Stack Overflow ou faça novas perguntas usando as marcas Azure e Go.
Caso encontre algum problema, relate um Problema do GitHub

Próximas etapas

Saiba mais sobre como usar o SDK do Azure para linguagem Go

Compartilhar via

Gerenciar grupos de recursos com o SDK do Azure para linguagem Go

1. Configurar os recursos do Azure

2. Definir variáveis de ambiente de autenticação

3. Criar um grupo de recursos

4. Verificar os resultados

5. Atualizar um grupo de recursos

6. Listar os grupos de recursos de uma assinatura do Azure

7. Excluir um grupo de recursos

8. Atualizar a função principal

Solução de problemas

Próximas etapas

Comentários

Recursos adicionais