Gerenciar grupos de recursos com o SDK do Azure para Go

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:

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

Antes de passar para a próxima seção, verifique se você anotou a ID da assinatura (Guid), a ID do locatário (Guid), a ID do cliente/aplicativo (Guid) e o segredo do principal de serviço.

2. Configurar a autenticação

Escolha um método de autenticação que atenda às suas necessidades. Oferecemos vários métodos de autenticação sem credenciais para aplicativos hospedados em ambientes locais e de servidores. Autenticar aplicativos Go nos serviços do Azure usando o artigo do SDK do Azure para Go ajudará você a decidir qual mecanismo de autenticação é o mais adequado para seu cenário.

3. Criar um grupo de recursos

Crie um diretório no qual testar e executar o código Go de exemplo e torná-lo o diretório atual.
Execute o 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, <module_path> ele não precisa se referir a um local real.
Execute o comando 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 das bibliotecas de gerenciamento da versão anterior 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 nomeado main.go e adicione o código a seguir. Cada seção de código é comentada para explicar sua finalidade.

package main

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

    "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    = "<your_subscription_id>"
    location          = "<your_region>"
    resourceGroupName = "<your_resource_group_name>" // !! 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)
}

As strings location e resourceGroupName são definidas para valores de teste. Se necessário, altere esses valores para algo apropriado para sua localização e assinatura.

Execute go mod tidy para limpar as dependências no arquivo go.mod com base no seu código-fonte.
```
go mod tidy
```
Execute go run para compilar 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 à 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

Retorne ao arquivo main.go.

Insira o código a seguir 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

Retorne ao arquivo main.go.

Insira o código a seguir 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

Retorne ao arquivo main.go.

Insira o código a seguir 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. Atualizar 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 essas funções sequencialmente:

Em 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

Observação

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

Resolução de problemas

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

Próximas etapas

Saiba mais sobre como usar o SDK do Azure para Go

Comentários

Esta página foi útil?

Last updated on 2025-09-11

Compartilhar via

Gerenciar grupos de recursos com o SDK do Azure para Go

1. Configurar recursos do Azure

2. Configurar a 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

Resolução de problemas

Próximas etapas

Comentários

Recursos adicionais