Compartir a través de

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

  • Artículo

Como se explica en el artículo ¿Qué es Azure SDK para Go?, Azure SDK para Go contiene un conjunto de bibliotecas de administración y cliente. Las bibliotecas de administración comparten muchas características, como la compatibilidad con Azure Identity, 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 para 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 comando go get.

Por ejemplo, para instalar el paquete armcompute, 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 mediante la instrucción import:

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 desea conectarse al servicio Azure Compute. El paquete armcompute 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 siguiente fragmento de código, se usa 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
}

Se usa el mismo patrón para conectarse a 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 de Azure SDK para Go

Una vez que se crea una instancia, los clientes se usan para realizar llamadas API a los recursos de Azure. En escenarios de administración de recursos, la mayoría de los casos de uso son operaciones CRUD (Crear, leer, actualizar o eliminar).

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

  1. Vaya a la documentación de referencia de Azure SDK para Go.
  2. Busque la página del paquete. (Presionar <Ctrl+F> expande 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 y la información sobre su uso en el código de Go.

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

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

En el ejemplo siguiente, se muestra cómo buscar la documentación de referencia para las operaciones de grupos 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. Busque 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 punto, puede leer cómo realizar la llamada API para crear un grupo de recursos de Azure.

Operaciones de larga duración

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

Como estas funciones son asincrónicas, su código no se bloquea hasta que la función finaliza su tarea. En su lugar, la función devuelve un objeto de sondeo inmediatamente. A continuación, el código llama a una función de sondeo sincrónica que 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