Inicio rápido: Creación de un recurso de Azure Managed CCF mediante Azure SDK para Go

  • Artículo

CCF administrado por Azure (CCF administrado) es un servicio nuevo y altamente seguro para implementar aplicaciones confidenciales. Para más información sobre Managed CCF, consulte Acerca de Azure Managed Confidential Consortium Framework.

En este inicio rápido, aprenderá a crear un recurso de Managed CCF mediante la biblioteca de Azure SDK para Go.

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

Documentación de referencia de la API | Código fuente de la biblioteca | Paquete (Go)

Requisitos previos

Instalación

Creación de una aplicación Go

  1. En un shell de comandos, ejecute el siguiente comando para crear una carpeta llamada managedccf-app:
mkdir managedccf-app && cd managedccf-app

go mod init github.com/azure/resourcemanager/confidentialledger

Instalación de los módulos

  1. Instale el módulo Azure Confidential Ledger.
go get -u github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confidentialledger/armconfidentialledger@v1.2.0-beta.1

Para este inicio rápido también deberá instalar el módulo de identidad de Azure para Go.

go get -u github.com/Azure/azure-sdk-for-go/sdk/azidentity

Crear un grupo de recursos

Un grupo de recursos es un contenedor lógico en el que se implementan y se administran los recursos de Azure. Use el cmdlet New-AzResourceGroup de Azure PowerShell para crear un grupo de recursos llamado myResourceGroup en la ubicación southcentralus.

New-AzResourceGroup -Name "myResourceGroup" -Location "SouthCentralUS"

Registrar el proveedor de recursos

El tipo de recurso CCF administrado de Azure debe estar registrado en la suscripción antes de crear un recurso.

az feature registration create --namespace Microsoft.ConfidentialLedger --name ManagedCCF

az provider register --namespace Microsoft.ConfidentialLedger

Crear miembros

Genere un par de claves para el miembro. Una vez completados los siguientes comandos, la clave pública del miembro se guarda en member0_cert.pem y la clave privada se guarda en member0_privk.pem.

openssl ecparam -out "member0_privk.pem" -name "secp384r1" -genkey
openssl req -new -key "member0_privk.pem" -x509 -nodes -days 365 -out "member0_cert.pem" -"sha384" -subj=/CN="member0"

Creación de la aplicación Go

La biblioteca del plano de administración permite operaciones en recursos de Managed CCF, como la creación y eliminación, enumerar los recursos asociados a una suscripción y ver los detalles de un recurso específico. En el siguiente fragmento de código se crean y se ven las propiedades de un recurso de Managed CCF.

Agregue las siguientes directivas al principio de main.go:

package main

import (
    "context"
    "log"
    
    "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/confidentialledger/armconfidentialledger"
)

Autenticación y creación de una fábrica de cliente

En este inicio rápido, se utiliza el usuario que ha iniciado sesión para autenticarse en Azure Managed CCF, que es el método preferido para el desarrollo local. En este ejemplo se usa la clase "NewDefaultAzureCredential()" del módulo de identidad de Azure, que permite usar el mismo código en entornos diferentes con distintas opciones para proporcionar la identidad.

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
    log.Fatalf("Failed to obtain a credential: %v", err)
}

Cree una factoría de cliente de Azure Resource Manager y autentíquela mediante la credencial del token.

ctx := context.Background()
clientFactory, err := armconfidentialledger.NewClientFactory("0000000-0000-0000-0000-000000000001", cred, nil)

if err != nil {
    log.Fatalf("Failed to create client: %v", err)
}

Creación de un recurso de Managed CCF

appName := "confidentialbillingapp"
rgName := "myResourceGroup"

// Create a new resource
poller, err := clientFactory.NewManagedCCFClient().BeginCreate(ctx, rgName, appName, armconfidentialledger.ManagedCCF{
    Location: to.Ptr("SouthCentralUS"),
    Tags: map[string]*string{
        "Department": to.Ptr("Contoso IT"),
    },
    Properties: &armconfidentialledger.ManagedCCFProperties{
        DeploymentType: &armconfidentialledger.DeploymentType{
            AppSourceURI:    to.Ptr(""),
            LanguageRuntime: to.Ptr(armconfidentialledger.LanguageRuntimeJS),
        },
        MemberIdentityCertificates: []*armconfidentialledger.MemberIdentityCertificate{
            {
                Certificate:   to.Ptr("-----BEGIN CERTIFICATE-----\nMIIU4G0d7....1ZtULNWo\n-----END CERTIFICATE-----"),
                Encryptionkey: to.Ptr(""),
                Tags: map[string]any{
                    "owner": "IT Admin1",
                },
            }},
        NodeCount: to.Ptr[int32](3),
    },
}, nil)

if err != nil {
    log.Fatalf("Failed to finish the request: %v", err)
}

_, err = poller.PollUntilDone(ctx, nil)

if err != nil {
    log.Fatalf("Failed to pull the result: %v", err)
}

Obtención de las propiedades del recurso de Managed CCF

El siguiente fragmento de código recupera el recurso de Managed CCF creado en el paso anterior.

log.Println("Getting the Managed CCF resource.")

// Get the resource details and print it
getResponse, err := clientFactory.NewManagedCCFClient().Get(ctx, rgName, appName, nil)

if err != nil {
    log.Fatalf("Failed to get details of mccf instance: %v", err)
}

// Print few properties of the Managed CCF resource
log.Println("Application name:", *getResponse.ManagedCCF.Properties.AppName)
log.Println("Node Count:", *getResponse.ManagedCCF.Properties.NodeCount)

Enumeración de los recursos de Managed CCF en un grupo de recursos

El siguiente fragmento de código recupera los recursos de Managed CCF en el grupo de recursos.

pager := clientFactory.NewManagedCCFClient().NewListByResourceGroupPager(rgName, nil)

for pager.More() {
    page, err := pager.NextPage(ctx)
    if err != nil {
        log.Fatalf("Failed to advance page: %v", err)
    }

    for _, v := range page.Value {
        log.Println("Application Name:", *v.Name)
    }
}

Eliminación del recurso de Managed CCF

En el siguiente fragmento de código se elimina el recurso de Managed CCF Otros artículos de Managed CCF pueden basase en este inicio rápido. Si tiene pensado seguir trabajando en otras guías de inicio rápido y tutoriales, considere la posibilidad de dejar estos recursos activos.

deletePoller, err := clientFactory.NewManagedCCFClient().BeginDelete(ctx, rgName, appName, nil)

if err != nil {
    log.Fatalf("Failed to finish the delete request: %v", err)
}

_, err = deletePoller.PollUntilDone(ctx, nil)

if err != nil {
    log.Fatalf("Failed to get the delete result: %v", err)
}

Limpieza de recursos

Otros artículos de Managed CCF pueden basase en este inicio rápido. Si tiene pensado seguir trabajando en otras guías de inicio rápido y tutoriales, considere la posibilidad de dejar estos recursos activos.

De lo contrario, cuando haya terminado con los recursos creados en este artículo, use el comando az group delete de la CLI de Azure para eliminar el grupo de recursos y todos los recursos que contiene.

az group delete --resource-group contoso-rg

Pasos siguientes

En este inicio rápido, ha creado un recurso de Managed CCF mediante el SDK de Python de Azure para Confidential Ledger. Para más información sobre Azure Managed CCF y cómo integrarlo con las aplicaciones, continúe con los artículos siguientes: