Partilhar via

Tutorial: Implantar recursos no MEC público do Azure usando o SDK Go

  • Artigo

Neste tutorial, você aprenderá a usar o SDK Go para implantar recursos no MEC (computação de borda de multiacesso) público do Azure. O tutorial fornece trechos de código escritos em Go para implantar uma máquina virtual e recursos IP públicos em uma solução MEC pública do Azure. Você pode usar o mesmo modelo e modelo para implantar outros recursos e serviços com suporte para o MEC público do Azure. Este artigo não se destina a ser um tutorial sobre Go; ele se concentra apenas nas chamadas de API necessárias para implantar recursos no MEC público do Azure.

Para obter mais informações sobre o Go, consulte Desenvolvedores do Azure for Go. Para obter exemplos do Go, consulte Exemplos do SDK do Azure Go.

Neste tutorial, irá aprender a:

  • Criar uma máquina virtual
  • Crie um endereço IP público
  • Implantar uma rede virtual e um endereço IP público

Pré-requisitos

  • Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.

  • Adicione uma assinatura permitida à sua conta do Azure, que permite implantar recursos no MEC público do Azure. Se você não tiver uma assinatura ativa permitida, entre em contato com a equipe de produto MEC pública do Azure.

Instalar o Go

Você pode baixar e instalar a versão mais recente do Go. Ele substituirá o Go existente na sua máquina. Se você quiser instalar várias versões do Go na mesma máquina, consulte Gerenciando instalações do Go.

Autenticação

Você precisa obter autenticação antes de usar qualquer serviço do Azure. Você pode usar a CLI do Azure para entrar ou definir variáveis de ambiente de autenticação.

Usar a CLI do Azure para entrar

Você pode usar az login na linha de comando para entrar no Azure por meio do seu navegador padrão. Instruções detalhadas podem ser encontradas em Entrar com CLI do Azure.

Definir variáveis de ambiente

Você precisa dos seguintes valores para autenticar no Azure:

  • ID da Subscrição
  • ID de Cliente
  • Segredo do Cliente
  • ID do Inquilino

Obtenha esses valores do portal seguindo estas instruções:

  • Obter ID de Subscrição

    1. Inicie sessão na sua conta do Azure
    2. Selecione Subscrições na barra lateral esquerda
    3. Selecione a assinatura necessária
    4. Selecione Descrição geral
    5. Copiar o ID da Subscrição

  • Obter ID do Cliente / Segredo do Cliente / ID do Inquilino

    Para obter informações sobre como obter ID do cliente, segredo do cliente e ID do locatário, consulte Criar um aplicativo e entidade de serviço do Microsoft Entra que possa acessar recursos.

  • Definindo variáveis de ambiente

    Depois de obter os valores, você precisa definir os seguintes valores como suas variáveis de ambiente:

    • AZURE_CLIENT_ID
    • AZURE_CLIENT_SECRET
    • AZURE_TENANT_ID
    • AZURE_SUBSCRIPTION_ID

    Para definir as seguintes variáveis de ambiente em seu sistema de desenvolvimento:

    Windows (acesso de administrador é necessário)

    1. Abra o Painel de Controlo
    2. Selecione Sistema de Segurança>do Sistema
    3. Selecione Configurações avançadas do sistema à esquerda
    4. Dentro da janela Propriedades do sistema, selecione o Environment Variables… botão.
    5. Selecione a propriedade que pretende alterar e, em seguida, selecione Editar.... Se o nome da propriedade não estiver listado, selecione Novo....

    SO baseado em Linux :

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

Instalar o pacote

O novo SDK usa módulos Go para controle de versão e gerenciamento de dependência.

Execute o seguinte comando para instalar os pacotes para este tutorial na pasta do projeto:

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

Aprovisionar uma máquina virtual

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

Clean up resources (Limpar recursos)

Neste tutorial, você criou uma VM no MEC público do Azure usando o SDK Go. Se você não espera precisar desses recursos no futuro, use o portal do Azure para excluir o grupo de recursos que você criou.

Próximos passos

Para implantar uma máquina virtual no MEC público do Azure usando o SDK do Python, avance para o seguinte artigo:

Tutorial: Implantar uma máquina virtual no MEC público do Azure usando o SDK do Python