Aracılığıyla paylaş

Öğretici: Go SDK'sını kullanarak Azure genel MEC'de kaynakları dağıtma

  • Makale

Bu öğreticide, Azure genel çoklu erişimli uç işlemde (MEC) kaynakları dağıtmak için Go SDK'sını kullanmayı öğreneceksiniz. Öğretici, Azure genel MEC çözümünde sanal makine ve genel IP kaynakları dağıtmak için Go ile yazılmış kod parçacıkları sağlar. Azure genel MEC için desteklenen diğer kaynakları ve hizmetleri dağıtmak için aynı modeli ve şablonu kullanabilirsiniz. Bu makale Go ile ilgili bir öğretici olarak tasarlanmamıştır; yalnızca Azure genel MEC'de kaynakları dağıtmak için gereken API çağrılarına odaklanır.

Go hakkında daha fazla bilgi için bkz . Go için Azure geliştiricileri. Go örnekleri için bkz . Azure Go SDK örnekleri.

Bu öğreticide aşağıdakilerin nasıl yapılacağını öğreneceksiniz:

  • Sanal makine oluşturun
  • Genel IP adresi oluşturma
  • Sanal ağ ve genel IP adresi dağıtma

Ön koşullar

  • Azure aboneliğiniz yoksa başlamadan önce ücretsiz bir hesap oluşturun.

  • Azure hesabınıza azure genel MEC'de kaynak dağıtmanıza olanak tanıyan izin verilenler listesine alınmış bir abonelik ekleyin. Etkin bir izin verilen aboneliğiniz yoksa Azure genel MEC ürün ekibine başvurun.

Go'u yükleme

Go'nun en son sürümünü indirip yükleyebilirsiniz. Makinenizde mevcut Go değerinin yerini alır. Aynı makineye birden çok Go sürümü yüklemek istiyorsanız bkz . Go yüklemelerini yönetme.

Kimlik Doğrulaması

Herhangi bir Azure hizmetini kullanmadan önce kimlik doğrulamasını almanız gerekir. Oturum açmak için Azure CLI kullanabilir veya kimlik doğrulama ortamı değişkenlerini ayarlayabilirsiniz.

Oturum açmak için Azure CLI kullanma

Varsayılan tarayıcınız aracılığıyla Azure'da oturum açmak için komut satırında kullanabilirsiniz az login . Ayrıntılı yönergeler Azure CLI ile oturum açma bölümünde bulunabilir.

Ortam değişkenlerini belirleme

Azure'da kimlik doğrulaması yapmak için aşağıdaki değerlere ihtiyacınız vardır:

  • Abonelik kimliği
  • İstemci kimliği
  • İstemci Gizli Dizisi
  • Kiracı Kimliği

Bu yönergeleri izleyerek bu değerleri portaldan alın:

  • Abonelik Kimliğini Alma

    1. Azure hesabınızda oturum açın
    2. Sol kenar çubuğunda Abonelikler'i seçin
    3. Hangi aboneliğin gerekli olduğunu seçin
    4. Genel Bakış'ı seçin
    5. Abonelik Kimliğini Kopyalama

  • İstemci Kimliği / İstemci Gizli Anahtarı / Kiracı Kimliği Alma

    İstemci Kimliği, İstemci Gizli Anahtarı ve Kiracı Kimliği alma hakkında bilgi için bkz . Kaynaklara erişebilen bir Microsoft Entra uygulaması ve hizmet sorumlusu oluşturma.

  • Ortam Değişkenlerini Ayarlama

    Değerleri aldıktan sonra aşağıdaki değerleri ortam değişkenleri olarak ayarlamanız gerekir:

    • AZURE_CLIENT_ID
    • AZURE_CLIENT_SECRET
    • AZURE_TENANT_ID
    • AZURE_SUBSCRIPTION_ID

    Geliştirme sisteminizde aşağıdaki ortam değişkenlerini ayarlamak için:

    Windows (Yönetici istrator erişimi gereklidir)

    1. Denetim Masası açma
    2. Sistem Güvenlik>Sistemi'ne tıklayın
    3. Soldaki Gelişmiş sistem ayarları'nı seçin
    4. Sistem Özellikler penceresi içinde düğmeyi Environment Variables… seçin.
    5. Değiştirmek istediğiniz özelliği seçin ve ardından Düzenle... seçeneğini belirleyin. Özellik adı listelenmiyorsa Yeni...'yi seçin.

    Linux tabanlı işletim sistemi :

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

paketini yükleyin

Yeni SDK, sürüm oluşturma ve bağımlılık yönetimi için Go modüllerini kullanır.

Bu öğreticinin paketlerini proje klasörünüz altına yüklemek için aşağıdaki komutu çalıştırın:

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

Sanal makine sağlama

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

Kaynakları temizleme

Bu öğreticide, Go SDK'sını kullanarak Azure genel MEC'de bir VM oluşturdunuz. Gelecekte bu kaynaklara ihtiyaç duymayı beklemiyorsanız, oluşturduğunuz kaynak grubunu silmek için Azure portalını kullanın.

Sonraki adımlar

Python SDK'sını kullanarak Azure genel MEC'de bir sanal makine dağıtmak için aşağıdaki makaleye ilerleyin:

Öğretici: Python SDK'sını kullanarak Azure genel MEC'de sanal makine dağıtma