Partager via

Tutoriel : Déployer des ressources dans Azure MEC public à l’aide du SDK Go

  • Article

Dans ce tutoriel, vous apprenez à utiliser le SDK Go pour déployer des ressources dans Azure Multi-Access Edge Compute (MEC) public. Ce tutoriel fournit des extraits de code écrits en Go pour déployer une machine virtuelle et des ressources IP publiques dans une solution Azure MEC public. Vous pouvez utiliser le même gabarit et le même modèle pour déployer d’autres ressources et services pris en charge pour Azure MEC public. Cet article n’est pas destiné à servir de tutoriel sur Go. Il se concentre uniquement sur les appels d’API requis pour déployer des ressources dans Azure MEC public.

Pour plus d’informations sur Go, consultez Azure pour les développeurs Go. Pour obtenir des exemples Go, consultez les exemples du SDK Go Azure.

Dans ce tutoriel, vous allez apprendre à :

  • Création d'une machine virtuelle
  • Créer une adresse IP publique
  • Déployer un réseau virtuel et une adresse IP publique

Prérequis

  • Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

  • Ajoutez un abonnement sur liste d’autorisation à votre compte Azure, ce qui vous permet de déployer des ressources dans Azure MEC public. Si vous n’avez pas d’abonnement autorisé actif, contactez l’équipe produit d’Azure MEC public.

Installer Go

Vous pouvez télécharger et installer la dernière version de Go. Il remplacera la version Go existante sur votre machine. Si vous souhaitez installer plusieurs versions de Go sur le même ordinateur, consultez Gestion des installations Go.

Authentification

Vous devez obtenir l’authentification avant d’utiliser un service Azure. =Vous pouvez utiliser Azure CLI pour vous connecter ou définir des variables d’environnement d’authentification.

Utilisez Azure CLI pour vous connecter

Vous pouvez utiliser az login dans la ligne de commande pour vous connecter à Azure via votre navigateur par défaut. Vous trouverez des instructions détaillées dans Se connecter avec Azure CLI.

Définir des variables d’environnement

Vous avez besoin des valeurs suivantes pour vous authentifier auprès d’Azure :

  • ID d’abonnement
  • ID client
  • Clé secrète client
  • Tenant ID

Obtenez ces valeurs à partir du portail en suivant ces instructions :

  • Obtenir l’ID d’abonnement

    1. Connectez-vous à votre compte Azure
    2. Sélectionnez Abonnements dans la barre latérale gauche
    3. Sélectionnez l’abonnement à utiliser
    4. Sélectionnez Vue d’ensemble
    5. Copiez l’ID d’abonnement

  • Obtenir l’ID client / la clé secrète client / l’ID de locataire

    Si vous souhaitez en savoir plus sur l’obtention de l’ID client, de la clé secrète client et de l’ID de tenant, veuillez consulter la rubrique Créer une application Azure Active Directory et un principal de service pouvant accéder aux ressources.

  • Définition des variables d'environnement

    Après avoir obtenu les valeurs, vous devez définir les valeurs suivantes comme variables d’environnement :

    • AZURE_CLIENT_ID
    • AZURE_CLIENT_SECRET
    • AZURE_TENANT_ID
    • AZURE_SUBSCRIPTION_ID

    Pour définir les variables d’environnement suivantes sur votre système de développement :

    Windows (l’accès administrateur est requis)

    1. Ouvrir le panneau de configuration
    2. Sélectionnez Système de sécurité>Système
    3. Sélectionnez Paramètres système avancés sur la gauche.
    4. Dans la fenêtre Propriétés du Système, sélectionnez le bouton Environment Variables….
    5. Sélectionnez la propriété que vous souhaitez modifier, puis sélectionnez Modifier.... Si le nom de la propriété n’est pas répertorié, sélectionnez Nouveau....

    Basé sur le système d’exploitation Linux :

        export AZURE_CLIENT_SECRET="__CLIENT_SECRET__"
    export AZURE_TENANT_ID="__TENANT_ID__"
    export AZURE_SUBSCRIPTION_ID="__SUBSCRIPTION_ID__"````

Installer le package

Le nouveau SDK utilise des modules Go pour le contrôle de version et la gestion des dépendances.

Exécutez la commande suivante pour installer les packages de ce didacticiel sous votre dossier de projet :

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v5
go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v3
go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources
go get github.com/Azure/azure-sdk-for-go/sdk/azcore
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity

Approvisionner une machine virtuelle

package main

import (
	"context"
	"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/compute/armcompute/v5"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v3"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources"
	"log"
	"os"
)

func main() {
	subscriptionId := os.Getenv("AZURE_SUBSCRIPTION_ID")

	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("authentication failure: %+v", err)
	}

	// client factory
	resourcesClientFactory, err := armresources.NewClientFactory(subscriptionId, cred, nil)
	if err != nil {
		log.Fatalf("cannot create client factory: %+v", err)
	}

	computeClientFactory, err := armcompute.NewClientFactory(subscriptionId, cred, nil)
	if err != nil {
		log.Fatalf("cannot create client factory: %+v", err)
	}

	networkClientFactory, err := armnetwork.NewClientFactory(subscriptionId, cred, nil)
	if err != nil {
		log.Fatalf("cannot create client factory: %+v", err)
	}

	// Step 1: Provision a resource group
	_, err = resourcesClientFactory.NewResourceGroupsClient().CreateOrUpdate(
		context.Background(),
		"<resourceGroupName>",
		armresources.ResourceGroup{
			Location: to.Ptr("westus"),
		},
		nil,
	)
	if err != nil {
		log.Fatal("cannot create resources group:", err)
	}

	// Step 2: Provision a virtual network
	virtualNetworksClientCreateOrUpdateResponsePoller, err := networkClientFactory.NewVirtualNetworksClient().BeginCreateOrUpdate(
		context.Background(),
		"<resourceGroupName>",
		"<virtualNetworkName>",
		armnetwork.VirtualNetwork{
			Location: to.Ptr("westus"),
			ExtendedLocation: &armnetwork.ExtendedLocation{
				Name: to.Ptr("<edgezoneid>"),
				Type: to.Ptr(armnetwork.ExtendedLocationTypesEdgeZone),
			},
			Properties: &armnetwork.VirtualNetworkPropertiesFormat{
				AddressSpace: &armnetwork.AddressSpace{
					AddressPrefixes: []*string{
						to.Ptr("10.0.0.0/16"),
					},
				},
				Subnets: []*armnetwork.Subnet{
					{
						Name: to.Ptr("test-1"),
						Properties: &armnetwork.SubnetPropertiesFormat{
							AddressPrefix: to.Ptr("10.0.0.0/24"),
						},
					},
				},
			},
		},
		nil,
	)
	if err != nil {
		log.Fatal("network creation failed", err)
	}
	virtualNetworksClientCreateOrUpdateResponse, err := virtualNetworksClientCreateOrUpdateResponsePoller.PollUntilDone(context.Background(), nil)
	if err != nil {
		log.Fatal("cannot create virtual network:", err)
	}
	subnetID := *virtualNetworksClientCreateOrUpdateResponse.Properties.Subnets[0].ID

	// Step 3: Provision an IP address
	publicIPAddressesClientCreateOrUpdateResponsePoller, err := networkClientFactory.NewPublicIPAddressesClient().BeginCreateOrUpdate(
		context.Background(),
		"<resourceGroupName>",
		"<publicIPName>",
		armnetwork.PublicIPAddress{
			Name:     to.Ptr("<publicIPName>"),
			Location: to.Ptr("westus"),
			ExtendedLocation: &armnetwork.ExtendedLocation{
				Name: to.Ptr("<edgezoneid>"),
				Type: to.Ptr(armnetwork.ExtendedLocationTypesEdgeZone),
			},
			SKU: &armnetwork.PublicIPAddressSKU{
				Name: to.Ptr(armnetwork.PublicIPAddressSKUNameStandard),
			},
			Properties: &armnetwork.PublicIPAddressPropertiesFormat{
				PublicIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodStatic),
			},
		},
		nil,
	)
	if err != nil {
		log.Fatal("public ip creation failed", err)
	}
	publicIPAddressesClientCreateOrUpdateResponse, err := publicIPAddressesClientCreateOrUpdateResponsePoller.PollUntilDone(context.Background(), nil)
	if err != nil {
		log.Fatal("cannot create public ip: ", err)
	}

	// Step 4: Provision the network interface client
	interfacesClientCreateOrUpdateResponsePoller, err := networkClientFactory.NewInterfacesClient().BeginCreateOrUpdate(
		context.Background(),
		"<resourceGroupName>",
		"<networkInterfaceName>",
		armnetwork.Interface{
			Location: to.Ptr("westus"),
			ExtendedLocation: &armnetwork.ExtendedLocation{
				Name: to.Ptr("<edgezoneid>"),
				Type: to.Ptr(armnetwork.ExtendedLocationTypesEdgeZone),
			},
			Properties: &armnetwork.InterfacePropertiesFormat{
				EnableAcceleratedNetworking: to.Ptr(true),
				IPConfigurations: []*armnetwork.InterfaceIPConfiguration{
					{
						Name: to.Ptr("<ipConfigurationName>"),
						Properties: &armnetwork.InterfaceIPConfigurationPropertiesFormat{
							Subnet: &armnetwork.Subnet{
								ID: to.Ptr(subnetID),
							},
							PublicIPAddress: &armnetwork.PublicIPAddress{
								ID: publicIPAddressesClientCreateOrUpdateResponse.ID,
							},
						},
					},
				},
			},
		},
		nil,
	)
	if err != nil {
		log.Fatal("interface creation failed", err)
	}
	interfacesClientCreateOrUpdateResponse, err := interfacesClientCreateOrUpdateResponsePoller.PollUntilDone(context.Background(), nil)
	if err != nil {
		log.Fatal("cannot create interface:", err)
	}

	// Step 5: Provision the virtual machine
	virtualMachinesClientCreateOrUpdateResponsePoller, err := computeClientFactory.NewVirtualMachinesClient().BeginCreateOrUpdate(
		context.Background(),
		"<resourceGroupName>",
		"<vmName>",
		armcompute.VirtualMachine{
			Location: to.Ptr("westus"),
			ExtendedLocation: &armcompute.ExtendedLocation{
				Name: to.Ptr("<edgezoneid>"),
				Type: to.Ptr(armcompute.ExtendedLocationTypesEdgeZone),
			},
			Properties: &armcompute.VirtualMachineProperties{
				StorageProfile: &armcompute.StorageProfile{
					ImageReference: &armcompute.ImageReference{
						Publisher: to.Ptr("<publisher>"),
						Offer:     to.Ptr("<offer>"),
						SKU:       to.Ptr("<sku>"),
						Version:   to.Ptr("<version>"),
					},
				},
				HardwareProfile: &armcompute.HardwareProfile{
					VMSize: to.Ptr(armcompute.VirtualMachineSizeTypesStandardD2SV3),
				},
				OSProfile: &armcompute.OSProfile{
					ComputerName:  to.Ptr("<computerName>"),
					AdminUsername: to.Ptr("<adminUsername>"),
					AdminPassword: to.Ptr("<adminPassword>"),
				},
				NetworkProfile: &armcompute.NetworkProfile{
					NetworkInterfaces: []*armcompute.NetworkInterfaceReference{
						{
							ID: interfacesClientCreateOrUpdateResponse.ID,
							Properties: &armcompute.NetworkInterfaceReferenceProperties{
								Primary: to.Ptr(true),
							},
						},
					},
				},
			},
		},
		nil,
	)
	if err != nil {
		log.Fatal("virtual machine creation failed", err)
	}
	_, err = virtualMachinesClientCreateOrUpdateResponsePoller.PollUntilDone(context.Background(), nil)
	if err != nil {
		log.Fatal("cannot create virtual machine:", err)
	}
}

Nettoyer les ressources

Dans ce tutoriel, vous avez créé une machine virtuelle dans Azure MEC public à l’aide du SDK Go. Si vous pensez ne pas avoir besoin de ces ressources à l’avenir, utilisez le portail Azure pour supprimer le groupe de ressources que vous avez créé.

Étapes suivantes

Pour déployer une machine virtuelle dans Azure MEC public à l’aide du SDK Python, passez à l’article suivant :

Tutoriel : Déployer une machine virtuelle dans Azure MEC public à l’aide du SDK Python