Gérer des groupes de ressources avec le Kit de développement logiciel (SDK) Azure pour Go

Dans cet article, vous allez apprendre à créer et à gérer un groupe de ressources avec la bibliothèque de gestion du Kit de développement logiciel (SDK) Azure pour Go.

1. Configurer des ressources Azure

Pour effectuer les étapes décrites dans cet article, vous avez besoin des ressources et identificateurs Azure suivants :

Abonnement Azure : Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
Obtenez l’ID d’abonnement Azure.
Obtenez l’ID de locataire Microsoft Entra.
Créez un principal de service. Notez l’ID et le secret de l’application (client) du principal de service. Veillez également à suivre les instructions pour attribuer le rôle Contributeur sur votre abonnement à l’application. Le rôle Contributeur est un rôle d’administrateur privilégié qui accorde l’autorisation de gérer toutes les ressources de votre abonnement.

Avant de passer à la section suivante, vérifiez que vous avez noté votre ID d’abonnement (Guid), votre ID de locataire (Guid) et l’ID client/application (Guid) et le secret de votre principal de service.

2. Configurer l’authentification

Choisissez une méthode d’authentification adaptée à vos besoins. Nous offrons plusieurs méthodes d’authentification sans informations d’identification pour les applications hébergées dans les environnements serveur et local. Authentifier les applications Go auprès des services Azure à l’aide de l’article du Kit de développement logiciel (SDK) Azure pour Go vous aidera à déterminer le mécanisme d’authentification le mieux adapté à votre scénario.

3. Créer un groupe de ressources

Créez un répertoire dans lequel tester et exécuter l’exemple de code Go et en faire le répertoire actif.
Exécutez go mod init pour créer un module dans le répertoire actif.
```
go mod init <module_path>
```
Points clés :
- Le <module_path> paramètre est généralement un emplacement dans un dépôt GitHub, tel que github.com/<your_github_account_name>/<directory>.
- Lorsque vous créez une application en ligne de commande en tant que test et que vous ne publierez pas l’application, il <module_path> n’est pas nécessaire de faire référence à un emplacement réel.
Exécutez go get pour télécharger, compiler et installer les modules nécessaires du SDK Azure pour 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
```
Important

Les packages de la version actuelle des bibliothèques de gestion des ressources Azure se trouvent dans sdk/**/arm**. Les packages de la version précédente des bibliothèques de gestion se trouvent sous /services. Si vous utilisez l’ancienne version, consultez le Guide de migration du Kit de développement logiciel (SDK) Azure pour Go.

Créez un fichier nommé main.go et ajoutez le code suivant. Chaque section de code est commentée pour expliquer son objectif.

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)
}

Les chaînes location et resourceGroupName sont définies sur des valeurs de test. Si nécessaire, remplacez ces valeurs par un élément approprié pour votre emplacement et votre abonnement.

Exécutez go mod tidy pour nettoyer les dépendances dans le go.mod fichier en fonction de votre code source.
```
go mod tidy
```
Exécutez go run pour générer et exécuter l’application.
```
go run .
```

4. Vérifier les résultats

Accédez au portail Azure.
Connectez-vous et sélectionnez votre abonnement Azure.
Dans le menu de gauche, sélectionnez Groupes de ressources.
Le nouveau groupe de ressources figure parmi les groupes de ressources de votre abonnement Azure.

Exécutez az group show pour afficher le groupe de ressources.

az group show --name <resource_group>

Exécutez Get-AzResourceGroup pour afficher le groupe de ressources.

Get-AzResourceGroup -Name <resource_group>

5. Mettre à jour un groupe de ressources

Revenez à votre main.go fichier.

Insérez le code suivant juste au-dessus de la main fonction.

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

Une fois que vous avez ajouté le code, passez à la section suivante. Vous exécutez le code dans une section ultérieure.

6. Répertorier les groupes de ressources d’un abonnement Azure

Revenez à votre main.go fichier.

Insérez le code suivant juste au-dessus de la main fonction.

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

Une fois que vous avez ajouté le code, passez à la section suivante. Vous exécutez le code dans une section ultérieure.

7. Supprimer un groupe de ressources

Revenez à votre main.go fichier.

Insérez le code suivant juste au-dessus de la main fonction.

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

Une fois que vous avez ajouté le code, passez à la section suivante. Vous exécutez le code dans une section ultérieure.

8. Mettre à jour la fonction principale

Dans les sections précédentes, vous avez ajouté du code pour main.go créer, mettre à jour et supprimer un groupe de ressources. Vous avez également ajouté du code pour répertorier tous les groupes de ressources d’un abonnement Azure. Pour exécuter toutes ces fonctions de manière séquentielle :

Dans main.go, remplacez la main fonction par le code suivant :

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")
}

Exécutez le code et observez la sortie.

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

Note

La suppression du groupe de ressources peut prendre quelques minutes.

Résolution des problèmes

Vérifiez les questions précédentes publiées sur Stack Overflow ou posez de nouvelles questions à l’aide des balises Azure et Go.
Pour toutes les erreurs que vous rencontrez, déposez un problème GitHub

Étapes suivantes

En savoir plus sur l’utilisation du Kit de développement logiciel (SDK) Azure pour Go

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-09-11

Partager via

Gérer des groupes de ressources avec le Kit de développement logiciel (SDK) Azure pour Go

1. Configurer des ressources Azure

2. Configurer l’authentification

3. Créer un groupe de ressources

4. Vérifier les résultats

5. Mettre à jour un groupe de ressources

6. Répertorier les groupes de ressources d’un abonnement Azure

7. Supprimer un groupe de ressources

8. Mettre à jour la fonction principale

Résolution des problèmes

Étapes suivantes

Commentaires

Ressources supplémentaires