Gerenciar grupos de recursos com o SDK do Azure para Go

Artigo
08/06/2024

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

1. Configurar recursos do Azure

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

Subscrição do Azure: se não tem uma subscrição do Azure, crie uma conta gratuita antes de começar.
Obtenha a ID de assinatura do Azure.
Obtenha a ID de locatário do Microsoft Entra.
Crie uma entidade de serviço. Anote o ID e o segredo do aplicativo (cliente) da entidade de serviço. Certifique-se também de seguir 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 privilegiada que concede permissão para gerenciar todos os recursos em sua assinatura.

Antes de passar para a próxima seção, certifique-se de ter anotado sua ID de assinatura (Guid), ID de locatário (Guid) e a ID do cliente/aplicativo (Guid) e 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 seu código possa se autenticar no Azure.

Bash
Windows

Defina as seguintes variáveis de ambiente. Substitua os espaços reservados pelos valores apropriados 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 seguintes variáveis de ambiente. Substitua os espaços reservados pelos valores apropriados 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 no qual testar e executar o código Go de exemplo e torne-o o diretório atual.
Execute go mod init para criar um módulo no diretório atual.
```
go mod init <module_path>
```
Pontos principais:
- O <module_path> parâmetro é geralmente um local em um repositório GitHub - como github.com/<your_github_account_name>/<directory>.
- Quando você está criando um aplicativo de linha de comando como um teste e não publica o aplicativo, o <module_path> não precisa se referir a um local real.
Execute go get para baixar, compilar e instalar os módulos necessários do SDK do Azure para Go.
```
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 para a versão atual das bibliotecas de gerenciamento de recursos do Azure estão localizados em sdk/**/arm**. Os pacotes para a versão anterior das bibliotecas de gerenciamento estão localizados em /services. Se você estiver usando a versão mais antiga, consulte o Guia de Migração do SDK do Azure para Go.

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

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 subscriptionId valor é recuperado da AZURE_SUBSCRIPTION_ID variável de ambiente.
As location cadeias de caracteres e resourceGroupName são definidas para testar valores. Se necessário, altere esses valores para algo apropriado para sua localização e assinatura.

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

4. Verificar os resultados

Navegue para o portal do Azure.
Entre e selecione sua assinatura do Azure.
No menu à esquerda, selecione Grupos de recursos.
O novo grupo de recursos está 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

Volte ao seu main.go ficheiro.

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

// 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

Volte ao seu main.go ficheiro.

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

// 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

Volte ao seu main.go ficheiro.

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

// 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. Atualize a função principal

Nas seções anteriores, você adicionou código para main.go 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 estas funções sequencialmente:

No main.go, substitua a main função pelo seguinte código:

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

Nota

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

Resolução de Problemas

Verifique as perguntas anteriores publicadas no Stack Overflow ou faça novas perguntas usando as Azure tags e Go .
Para quaisquer erros que você encontrar, registre um problema no GitHub

Próximos passos

Saiba mais sobre como usar o SDK do Azure para Go

Partilhar via

Gerenciar grupos de recursos com o SDK do Azure para Go

1. Configurar 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. Atualize a função principal

Resolução de Problemas

Próximos passos

Comentários

Recursos adicionais