Dela via

Självstudie: Distribuera resurser i azure public MEC med hjälp av Go SDK

  • Artikel

I den här självstudien får du lära dig hur du använder Go SDK för att distribuera resurser i Azure public multi-access edge compute (MEC). Självstudien innehåller kodfragment skrivna i Go för att distribuera en virtuell dator och offentliga IP-resurser i en offentlig MEC-lösning i Azure. Du kan använda samma modell och mall för att distribuera andra resurser och tjänster som stöds för azure public MEC. Den här artikeln är inte avsedd att vara en självstudie om Go. den fokuserar bara på de API-anrop som krävs för att distribuera resurser i azure public MEC.

Mer information om Go finns i Azure for Go-utvecklare. För Go-exempel, se Azure Go SDK-exempel.

I den här självstudien lär du dig att:

  • Skapa en virtuell dator
  • Skapa en offentlig IP-adress
  • Distribuera ett virtuellt nätverk och en offentlig IP-adress

Förutsättningar

  • Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.

  • Lägg till en tillåten prenumeration på ditt Azure-konto, vilket gör att du kan distribuera resurser i azure public MEC. Om du inte har en aktiv tillåten prenumeration kontaktar du azures offentliga MEC-produktteam.

Installera Go

Du kan ladda ned och installera den senaste versionen av Go. Den ersätter den befintliga Go på datorn. Om du vill installera flera Go-versioner på samma dator kan du läsa Hantera Go-installationer.

Autentisering

Du måste skaffa autentisering innan du använder någon Azure-tjänst. Du kan antingen använda Azure CLI för att logga in eller ange miljövariabler för autentisering.

Använda Azure CLI för att logga in

Du kan använda az login på kommandoraden för att logga in på Azure via standardwebbläsaren. Detaljerade instruktioner finns i Logga in med Azure CLI.

Ange miljövariabler

Du behöver följande värden för att autentisera till Azure:

  • Prenumerations-ID
  • Klient-ID
  • Klienthemlighet
  • Tenant ID

Hämta dessa värden från portalen genom att följa dessa instruktioner:

  • Hämta prenumerations-ID

    1. Logga in på ditt Azure-konto
    2. Välj Prenumerationer i det vänstra sidofältet
    3. Välj vilken prenumeration som behövs
    4. Välj Översikt
    5. Kopiera prenumerations-ID:t

  • Hämta klient-ID/Klienthemlighet/Klient-ID

    Information om hur du hämtar klient-ID, klienthemlighet och klient-ID finns i Skapa ett Microsoft Entra-program och tjänstens huvudnamn som kan komma åt resurser.

  • Ange miljövariabler

    När du har hämtat värdena måste du ange följande värden som miljövariabler:

    • AZURE_CLIENT_ID
    • AZURE_CLIENT_SECRET
    • AZURE_TENANT_ID
    • AZURE_SUBSCRIPTION_ID

    Så här anger du följande miljövariabler i ditt utvecklingssystem:

    Windows (administratörsåtkomst krävs)

    1. Öppna Kontrolna tabla
    2. Välj Systemsäkerhetssystem>
    3. Välj Avancerade systeminställningar till vänster
    4. Välj knappen i fönstret Environment Variables… Systemegenskaper.
    5. Välj den egenskap som du vill ändra och välj sedan Redigera.... Om egenskapsnamnet inte visas väljer du Nytt....

    Linux-baserat operativsystem :

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

Installera -paketet

Den nya SDK:n använder Go-moduler för versionshantering och beroendehantering.

Kör följande kommando för att installera paketen för den här självstudien under projektmappen:

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

Etablera en virtuell dator

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

Rensa resurser

I den här självstudien skapade du en virtuell dator i azure public MEC med hjälp av Go SDK. Om du inte förväntar dig att behöva dessa resurser i framtiden använder du Azure-portalen för att ta bort den resursgrupp som du skapade.

Nästa steg

Om du vill distribuera en virtuell dator i azure public MEC med hjälp av Python SDK går du vidare till följande artikel:

Självstudie: Distribuera en virtuell dator i azure public MEC med hjälp av Python SDK