Tutorial: Implantar recursos na MEC pública do Azure usando o SDK do Go
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
- Fazer logon na sua conta do Azure
- Selecione Assinaturas na barra lateral à esquerda
- Selecione qualquer assinatura necessária
- Selecione Visão geral
- 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_IDAZURE_CLIENT_SECRETAZURE_TENANT_IDAZURE_SUBSCRIPTION_ID
Para definir as seguintes variáveis de ambiente em seu sistema de desenvolvimento:
Windows (o acesso de administrador é necessário)
- Abrir o Painel de Controle
- Selecione Segurança do Sistema>Sistema
- Selecione Configurações avançadas do sistema à esquerda
- Dentro da janela Propriedades do Sistema, selecione o botão
Environment Variables…. - 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:
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de