Commencer avec Azure SDK pour Go

Cet article vous guide à travers les bases de l’utilisation d’Azure SDK pour Go, avec une attention particulière à la création de pilotes de stockage à utiliser sur une interface de ligne de commande (CLI). Ceci est un composant d’un projet de recherche plus large pour développer une CLI pour sauvegarder des bases de données PostgreSQL et envoyer les sauvegardes vers un compte de stockage Azure.

Commencer avec Azure SDK pour Go : Un voyage dans le développement des pilotes de stockage

Azure SDK pour Go est un outil essentiel pour le développement logiciel dans l’environnement cloud Azure. Il offre aux développeurs un moyen puissant, dynamique et interactif d’interagir avec les services Azure en utilisant le langage de programmation Go. Cet article vous guide à travers les bases de l’utilisation d’Azure SDK pour Go, avec une attention particulière à la création de pilotes de stockage utilisable en ligne de commande (CLI). Ceci fait partie du projet de recherche global pour créer une CLI pour effectuer des sauvegardes de bases de données PostgreSQL et les envoyer à un compte de stockage Azure.

Commencer avec Azure SDK pour Go

Azure SDK pour Go offre de nombreuses fonctionnalités, de la gestion des ressources Azure au traitement des données des services de stockage Azure. Il est conçu pour être facile à utiliser, efficient et flexible selon les besoins de développement. Pour commencer à utiliser Azure SDK pour Go, vous devez l’installer en utilisant la commande go :

go get -u github.com/Azure/azure-sdk-for-go/...

Une fois installé, vous pouvez importer les packages nécessaires dans votre code Go et interagir avec les services Azure.

Configuration des variables d’environnement

Avant de commencer à interagir avec les services Azure, vous devez configurer les variables d’environnement suivantes :

export AZURE_CLIENT_ID="__CLIENT_ID__"
export AZURE_CLIENT_SECRET="__CLIENT_SECRET__"
export AZURE_TENANT_ID="__TENANT_ID__"
export AZURE_SUBSCRIPTION_ID="__SUBSCRIPTION_ID__"

Ces variables d’environnement sont utilisées par Azure SDK pour Go pour authentifier votre application avec Azure.

Authentification à Azure

Pour exécuter du code sur un abonnement Azure, vous devez vous authentifier auprès d’Azure. Le package azidentity offre plusieurs options pour s’authentifier auprès d’Azure, y compris client/secret, certificat et identité gérée. Voici comment créer un objet azidentity :

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
  // traiter l'erreur
}

Ce code utilise les variables d’environnement configurées précédemment pour s’authentifier auprès d’Azure.

Création de ressources Azure

Pour configurer les ressources Azure, vous devez d’abord décider quel client vous souhaitez utiliser. Par exemple, si vous voulez créer un groupe, vous pouvez utiliser ResourceGroupsClient. Une fois le client défini, vous pouvez l’utiliser pour effectuer des appels API pour créer, mettre à jour, lire ou supprimer des ressources Azure. La plupart de ces opérations sont des opérations CRUD (créer/lire/mettre à jour/supprimer).

Voici un exemple de création d’un ressource group:

ctx := context.Background()
resourceGroupName := "testresourcegroup"
location := "francecentral"

resourceGroupParameters := armresources.ResourceGroup{
  Location: to.StringPtr(location),
}

_, err = resourceGroupsClient.CreateOrUpdate(ctx, resourceGroupName, resourceGroupParameters, nil)
if err != nil {
  // traiter l'erreur
}

Dans cet exemple, nous créons d’abord un contexte, puis définissons le nom et l’emplacement du groupe de ressources que nous voulons créer. Ensuite, nous créons un objet ResourceGroup avec l’emplacement spécifié, et enfin, nous appelons la méthode CreateOrUpdate du resourceGroupsClient pour créer le groupe de ressources.

Opérations à long terme

Certains projets Azure peuvent prendre beaucoup de temps à terminer. L’Azure SDK pour Go fournit un support pour les opérations à long terme (LROs) via des appels asynchrones. Cette liste de fonctions commence par Start et renvoie un objet Poller. L’objet poller est utilisé pour interroger périodiquement le service jusqu’à ce qu’il soit terminé. Voici un exemple de ce type :

ctx := context.Background()
poller, err := client.BeginCreate(ctx, "resource_identifier", "additional_parameter")
if err != nil {
  // traiter l'erreur...
}
resp, err = poller.PollUntilDone(ctx, nil)
if err != nil {
  // traiter l'erreur...
}
fmt.Printf("LRO terminé")

Dans cet exemple, nous appelons d’abord une fonction asynchrone pour créer un client, qui renvoie un objet Poller. Nous appelons ensuite la fonction PollUntilDone de l’objet Poller, qui bloque jusqu’à ce que la fonction asynchrone d’origine soit terminée.

Développement des pilotes de stockage avec Azure SDK pour Go

L’une des utilisations les plus courantes de l’Azure SDK pour Go est l’interaction avec Azure Blob Storage. C’est une solution évolutive, sécurisée et rentable pour stocker de grandes quantités de données non structurées. Dans notre cas, nous voulons l’utiliser pour stocker des sauvegardes de bases de données PostgreSQL.

Pour interagir avec Azure Blob Storage, vous devez créer une instance du type BlobServiceClient. Cette instance représente le compte de stockage Azure et est utilisée pour effectuer des opérations sur les blobs à l’intérieur du compte. Voici comment créer un BlobServiceClient :

accountName, accountKey := "<azure-account-name>", "<azure-account-key>"
credential, _ := azblob.NewSharedKeyCredential(accountName, accountKey)
client, _ := azblob.NewServiceClient(fmt.Sprintf("https://%s.blob.core.windows.net/", accountName), credential, nil)

Dans le code ci-dessus, nous créons d’abord une clé partagée avec le nom et la clé du compte Azure. Ensuite, nous créons un nouveau client de service en utilisant la clé partagée.

Intégrer les pilotes de stockage dans une CLI

Nous pouvons créer une fonction Go qui interagit avec le stockage Azure Blob. Cette fonction peut être étendue à la CLI pour fournir un moyen facile de gérer des ressources telles que les sauvegardes de bases de données PostgreSQL.

pisq est une CLI qui utilise le SDK Azure pour télécharger des sauvegardes sur un compte de stockage Azure. La fonctionnalité Upload est un exemple clair de cette intégration:

 package azure

 import (
   "context"
   "fmt"
   "net/url"
   "os"

   "github.com/charmbracelet/log"

   "github.com/Azure/azure-storage-blob-go/azblob"
 )

 func Upload(azureContainerName string, backupPath, azureAccountName string, azureAccountKey string) {
   credential, err := azblob.NewSharedKeyCredential(azureAccountName, azureAccountKey)
   if err != nil {
     log.Fatalf("Mauvaises informations d'identification : %v", err)
   }
   pipeline := azblob.NewPipeline(credential, azblob.PipelineOptions{})
   URL, _ := url.Parse(
     fmt.Sprintf("https://%s.blob.core.windows.net/%s", azureAccountName, azureContainerName))

   containerURL := azblob.NewContainerURL(*URL, pipeline)

   file, err := os.Open(backupPath)
   if err != nil {
     log.Fatalf("Le fichier existe déjà :%v", err)
   }
   defer file.Close()

   blockBlobURL := containerURL.NewBlockBlobURL(backupPath)
   _, err = azblob.UploadFileToBlockBlob(context.Background(), file, blockBlobURL, azblob.UploadToBlockBlobOptions{})
   if err != nil {
     log.Error("Erreur lors du téléchargement du fichier dans le conteneur du compte de stockage Azure", err)
   } else {
     log.Info("Le téléchargement a réussi!")
   }
 }

Cette fonction prend le nom du conteneur, le chemin vers le fichier de sauvegarde, le nom du compte Azure et la clé du compte Azure comme paramètres. Elle crée d’abord une identification partagée à l’aide du nom et de la clé du compte Azure. Un pipeline est ensuite créé avec ces informations d’identification. Une URL est générée pour le conteneur de stockage Blob Azure, et une nouvelle URL de conteneur est créée avec le pipeline. La fonction ouvre ensuite le fichier de sauvegarde et crée une nouvelle URL de blob. Enfin, le fichier de sauvegarde est téléchargé dans le blob.

Conclusion

Le SDK Azure pour Go fourni un moyen puissant et efficace d’interagir avec les services Azure. En utilisant ce SDK, vous pouvez gérer et interagir directement avec les ressources Azure depuis votre application Go. Que ce soit pour configurer des modifications d’environnement et l’authentification dans Azure, pour mettre en place des ressources Azure ou pour héberger des charges de travail à long terme, le SDK Azure pour Go vous offre tout ce dont vous avez besoin.

L’intégration de ce SDK à la CLI montre qu’il est possible de construire des pilotes, comme illustré dans pisq. Cette intégration permet une gestion facile des ressources telles que les sauvegardes de bases de données PostgreSQL directement depuis la CLI.

À mesure qu’Azure continue de s’améliorer et d’étendre ses capacités, le SDK Azure pour Go devient un outil fiable pour les développeurs. Il est conçu pour suivre la croissance d’Azure, offrant aux développeurs les outils pour construire, gérer et optimiser leurs applications sur la plateforme Azure.