Compartir a través de

Introducción a las bibliotecas de administración de Azure SDK para Go

Como se explica en el artículo ¿Qué es azure SDK para Go?, el SDK de Azure para Go contiene un conjunto de bibliotecas cliente y de administración. Las bibliotecas de administración comparten muchas características, como la compatibilidad con identidades de Azure, la canalización HTTP y el control de errores. Puede encontrar la lista completa de las bibliotecas de administración en la página del módulo Azure SDK for Go.

En este artículo, aprenderá los pasos básicos de cómo usar las bibliotecas de administración para interactuar con los recursos de Azure.

Instalación de paquetes de Go

En la mayoría de los proyectos, se instalan los paquetes de Go para el control de versiones y la administración de dependencias.

Para instalar un paquete de Go, use el go get comando .

Por ejemplo, para instalar el armcompute paquete, ejecute lo siguiente en la línea de comandos:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute

En la mayoría de las aplicaciones de Go, se instalan los siguientes paquetes para la autenticación:

  • github.com/Azure/azure-sdk-for-go/sdk/azcore/to
  • github.com/Azure/azure-sdk-for-go/sdk/azidentity

Importación de paquetes en el código de Go

Una vez descargado, el paquete se importa en la aplicación a través de la import instrucción :

import (
    "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"
)

Autenticación en Azure

Para ejecutar código en una suscripción de Azure, debe autenticarse en Azure. El paquete azidentity admite varias opciones para autenticarse en Azure. Estas opciones incluyen cliente/secreto, certificado e identidad administrada.

La opción de autenticación predeterminada es DefaultAzureCredential, que usa las variables de entorno establecidas anteriormente en este artículo. En el código de Go, creará un azidentity objeto de la siguiente manera:

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
  // handle error
}

Creación de un cliente de Administración de recursos

Una vez que tenga una credencial de Azure Identity, cree un cliente para conectarse al servicio de Azure de destino.

Por ejemplo, supongamos que quiere conectarse al servicio Azure Compute . El paquete compute consta de uno o varios clientes. Un cliente agrupa un conjunto de API relacionadas, lo que proporciona acceso a su funcionalidad dentro de la suscripción especificada. Cree uno o varios clientes para acceder a las API que necesita.

En el fragmento de código siguiente, se utiliza el tipo armcompute.NewVirtualMachinesClient para crear un cliente para administrar máquinas virtuales.

client, err := armcompute.NewVirtualMachinesClient("<subscription ID>", cred, nil)
if err != nil {
  // handle error
}

El mismo patrón se usa para conectarse con otros servicios de Azure. Por ejemplo, instale el paquete armnetwork y cree un cliente de red virtual para administrar recursos de red virtual (VNET).

client, err := armnetwork.NewVirtualNetworksClient("<subscription ID>", cred, nil)
if err != nil {
  // handle error
}

Ejemplo de código:

package main

import (
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		// handle error
	}
	client, err := armcompute.NewVirtualMachinesClient("SubID", cred, nil)
	if err != nil {
        // handle error
    }
}

Uso de la documentación de referencia del SDK de Azure para Go

Una vez que se crea una instancia, los clientes se usan para realizar llamadas API a los recursos de Azure. Para escenarios de administración de recursos, la mayoría de los casos de uso son operaciones CRUD (Create/Read/Update/Delete).

Para buscar las operaciones de un tipo específico, siga estos pasos:

  1. Vaya a la documentación de referencia del SDK de Azure para Go.
  2. Busque el paquete en la página. (Al presionar <Ctrl+F> , se expanden automáticamente todos los nodos de la página para buscar).
  3. Seleccione el paquete.
  4. Busque el tipo en la página del paquete.
  5. Lea la descripción del tipo e información sobre su uso en el código de Go.

También puede compilar manualmente la dirección URL anexando el nombre del paquete a github.com/Azure/azure-sdk-for-go/sdk/.

Por ejemplo, si busca la compute/armcompute documentación de referencia, la dirección URL es github.com/Azure/azure-sdk-for-go/sdk/compute/armcompute.

En el ejemplo siguiente se muestra cómo encontrar la documentación de referencia para las operaciones del grupo de recursos de Azure:

  1. Vaya a la documentación de referencia principal del SDK de Azure para Go en pkg.go.dev.
  2. Seleccione <Ctrl+F> y escriba resourcemanager/resources/armresources. A medida que escribe el término de búsqueda, verá una coincidencia cercana con el paquete resources/armresources .
  3. Seleccione el paquete adecuado para la aplicación.
  4. Lea las secciones "Introducción" o busque una operación específica. Por ejemplo, la búsqueda del término "resourcegroupsclient.create" (si desea crear un grupo de recursos) le lleva a la función CreateOrUpdate.
  5. En este momento, puede leer cómo realizar la llamada API para crear un grupo de recursos de Azure.

Operaciones de larga duración

Dado que algunas operaciones pueden tardar mucho tiempo en completarse, las bibliotecas de administración contienen funciones para admitir operaciones de larga duración (LRO) a través de llamadas asincrónicas. Estos nombres de función comienzan por Begin. Algunos ejemplos de este patrón son BeginCreate y BeginDelete.

Dado que estas funciones son asincrónicas, el código no se bloquea hasta que la función finaliza su tarea. En su lugar, la función devuelve inmediatamente un objeto poller. A continuación, el código llama a una función de sondeo sincrónica que se devuelve cuando se completa la función asincrónica original.

El siguiente fragmento de código muestra un ejemplo de este patrón.

ctx := context.Background()
// Call an asynchronous function to create a client. The return value is a poller object.
poller, err := client.BeginCreate(ctx, "resource_identifier", "additional_parameter")

if err != nil {
	// handle error...
}

// Call the poller object's PollUntilDone function that will block until the poller object
// has been updated to indicate the task has completed.
resp, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	// handle error...
}

// Print the fact that the LRO completed.
fmt.Printf("LRO done")

// Work with the response ("resp") object.

Puntos clave:

Pasos siguientes

Administración de grupos de recursos de Azure