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:

Subscrição do Azure: Se você não tiver uma assinatura 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 do aplicativo (cliente) e o segredo do principal 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 a sua ID de assinatura (Guid), ID de locatário (Guid) e a ID do cliente/aplicativo (Guid) e o segredo do seu principal de serviço.

2. Configurar a autenticação

Escolha um método de autenticação que se adapte às suas necessidades. Oferecemos vários métodos de autenticação sem credenciais para aplicativos hospedados em ambientes locais e de servidor. Autenticar aplicativos Go para serviços do Azure usando o artigo 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 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"

    "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 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 tidy para limpar as dependências no go.mod arquivo com base no 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

Observação

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

Soluçã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

Feedback

Esta página foi útil?

Last updated on 2025-09-11

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

Solução de problemas

Próximos passos

Feedback

Recursos adicionais