Tutorial: Implementación de recursos en el MEC público de Azure mediante el SDK de Go

  • Artículo

En este tutorial, obtendrá información sobre cómo utilizar Go SDK para implementar recursos en la versión preliminar del proceso perimetral multiacceso (MEC) público de Azure. El tutorial proporciona fragmentos de código escritos en Go para implementar una máquina virtual y recursos de dirección IP pública en una solución de MEC público de Azure. Puede usar el mismo modelo y plantilla para implementar otros recursos y servicios compatibles con MEC público de Azure. Este artículo no está pensado para ser un tutorial sobre Go; solo se centra en las llamadas API necesarias para implementar recursos en MEC público de Azure.

Para más información sobre Go, consulte Azure para desarrolladores de Go. Para obtener ejemplos de Go, consulte Ejemplos del SDK de Azure para Go.

En este tutorial, aprenderá a:

  • Creación de una máquina virtual
  • Crear una dirección IP pública
  • Implementación de una red virtual y una dirección IP pública

Requisitos previos

  • Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

  • Agregue una suscripción de la lista de permitidos a su cuenta de Azure, lo que le permite implementar recursos en MEC público de Azure. Si no tiene ninguna suscripción permitida activa, póngase en contacto con el equipo de producto de MEC público de Azure.

Instalación de Go

Puede descargar e instalar la versión más reciente de Go. Reemplazará la versión de Go existente en la máquina. Si desea instalar varias versiones de Go en la misma máquina, consulte Administración de instalaciones de Go.

Autenticación

Debe obtener la autenticación antes de usar cualquier servicio de Azure. Puede usar la CLI de Azure para iniciar sesión o establecer variables de entorno de autenticación.

Usar la CLI de Azure para iniciar sesión

Puede usar az login en la línea de comandos para iniciar sesión en Azure a través del explorador predeterminado. Encontrará instrucciones detalladas en Inicio de sesión con la CLI de Azure.

Establecimiento de variables de entorno

Necesita los siguientes valores para autenticarse en Azure:

  • Id. de suscripción
  • Id de cliente
  • Secreto de cliente
  • Id. de inquilino

Para obtener estos valores en el portal, siga estas instrucciones:

  • Obtenga el id. de suscripción

    1. Inicie sesión en la cuenta de Azure.
    2. Seleccione Suscripciones en la barra lateral izquierda
    3. Seleccione la suscripción que necesite.
    4. Seleccione Información general.
    5. Copie el valor de Id. de suscripción

  • Obtener el identificador de cliente/secreto de cliente/identificador de inquilino

    Para obtener información sobre cómo obtener el identificador de cliente, el secreto de cliente y el identificador de inquilino, consulte Creación de una aplicación de Microsoft Entra y una entidad de servicio que puedan acceder a los recursos.

  • Establecimiento de variables de entorno

    Después de obtener los valores, debe establecer los valores siguientes como variables de entorno:

    • AZURE_CLIENT_ID
    • AZURE_CLIENT_SECRET
    • AZURE_TENANT_ID
    • AZURE_SUBSCRIPTION_ID

    Para establecer las siguientes variables de entorno en el sistema de desarrollo:

    Windows (se requiere acceso de administrador)

    1. Abrir el Panel de control
    2. Seleccione Seguridad del sistema>Sistema
    3. Seleccione Configuración avanzada del sistema a la izquierda
    4. En la ventana Propiedades del sistema, seleccione el botón Environment Variables….
    5. Seleccione la propiedad que desea cambiar y, a continuación, Editar.... Si el nombre de la propiedad no aparece en la lista, seleccione Nuevo....

    Basado en el sistema operativo Linux:

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

Instalar el paquete

El nuevo SDK usa módulos de Go para el control de versiones y la administración de dependencias.

Ejecute el siguiente comando para instalar los paquetes de este tutorial en la carpeta del proyecto:

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

Aprovisionamiento de una 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)
	}
}

Limpieza de recursos

En este tutorial, ha creado una máquina virtual en MEC público de Azure mediante el SDK para Go. Si no espera necesitar estos recursos en el futuro, use Azure Portal para eliminar el grupo de recursos que ha creado.

Pasos siguientes

Para implementar una máquina virtual en MEC público de Azure mediante el SDK para Python, consulte el siguiente artículo:

Tutorial: Implementación de una máquina virtual en la versión preliminar de MEC público de Azure mediante el SDK para Python