Compartilhar via

Tutorial: Implantar recursos na MEC pública do Azure usando o SDK do Go

  • Artigo

Neste tutorial, você aprenderá a usar o SDK do Go para implantar recursos na MEC (Computação de Borda de Acesso Múltiplo) pública do Azure. O tutorial fornece snippets de código escritos em Go para implantar uma máquina virtual e recursos de IP público em uma solução da MEC pública do Azure. Você pode usar o mesmo modelo para implantar outros recursos e serviços compatíveis com a MEC pública do Azure. Este artigo não se destina a ser um tutorial sobre o Go. Ele tem como foco as chamadas à API necessárias para implantar recursos na MEC pública do Azure.

Para saber mais sobre o Go, confira Azure para desenvolvedores do Go. Para ver exemplos do Go, confira Exemplos do SDK do Go para Azure.

Neste tutorial, você aprenderá como:

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

Pré-requisitos

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

  • Adicione uma assinatura incluída na lista de permitidos à sua conta do Azure, o que permite que você implante recursos na MEC pública do Azure. Caso você não tenha uma assinatura ativa permitida, entre em contato com a equipe de produto da MEC pública do Azure.

Instalar o Go

Você pode baixar e instalar a versão mais recente do Go. Ela substituirá o Go já existente em seu computador. Se você quiser instalar várias versões do Go no mesmo computador, confira como Gerenciar as instalações do Go.

Autenticação

Você precisa obter a 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 para autenticação.

Use a CLI do Azure para entrar

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

Definir variáveis de ambiente

Você precisa dos seguintes valores para se autenticar no Azure:

  • ID da assinatura
  • ID do Cliente
  • Segredo do Cliente
  • ID do locatário

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

  • Obter ID da Assinatura

    1. Fazer logon na sua conta do Azure
    2. Selecione Assinaturas na barra lateral à esquerda
    3. Selecione qualquer assinatura necessária
    4. Selecione Visão geral
    5. Copie a ID da Assinatura

  • Obter a ID do Cliente/Segredo do Cliente/ID do Locatário

    Para obter informações sobre como obter a ID do Cliente, o Segredo do Cliente e a ID do Locatário, confira como Criar um aplicativo do Microsoft Entra e uma entidade de serviço que possa acessar recursos.

  • Configurando Variáveis de Ambiente

    Depois de obter os valores, você precisa definir os seguintes valores como 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 (o acesso de administrador é necessário)

    1. Abrir o Painel de Controle
    2. Selecione Segurança do Sistema>Sistema
    3. Selecione Configurações avançadas do sistema à esquerda
    4. Dentro da janela Propriedades do Sistema, selecione o botão Environment Variables….
    5. Selecione a propriedade que você deseja alterar e 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ências.

Execute o seguinte comando para instalar os pacotes deste 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

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

Limpar os recursos

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

Próximas etapas

Para implantar uma máquina virtual na MEC pública do Azure usando o SDK do Python, prossiga para o seguinte artigo:

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