Compartir a través de

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

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

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

Si no tiene una cuenta de Azure, cree una cuenta gratuita antes de comenzar.

Documentación | de referencia de APICódigo | fuente de la bibliotecaPaquete (Go)

Prerrequisitos

Configuración

Creación de una nueva aplicación de Go

  1. En un shell de comandos, ejecute el comando siguiente para crear una carpeta denominada 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 debe instalar el módulo Azure Identity para Go.

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

Creación de un grupo de recursos

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

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

Registro del 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 CCF administrados, como la creación y eliminación, enumerar los recursos asociados a una suscripción y ver los detalles de un recurso específico. El siguiente fragmento de código crea y ve las propiedades de un recurso CCF administrado.

Agregue las siguientes directivas a la parte superior 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 factoría de cliente

En este inicio rápido, el usuario que ha iniciado sesión se usa 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 Azure Identity, que permite usar el mismo código en distintos entornos con distintas opciones para proporcionar 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 CCF administrado

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 CCF administrado

El siguiente fragmento de código recupera el recurso CCF administrado 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 CCF administrados en un grupo de recursos

El siguiente fragmento de código recupera los recursos ccF administrados del 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 CCF administrado

El siguiente fragmento de código elimina el recurso CCF administrado. Otros artículos de CCF administrados pueden basase en este inicio rápido. Si tiene previsto seguir trabajando con inicios rápidos y tutoriales posteriores, es posible que desee dejar estos recursos en su lugar.

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 CCF administrados pueden basase en este inicio rápido. Si tiene previsto seguir trabajando con inicios rápidos y tutoriales posteriores, es posible que desee dejar estos recursos en su lugar.

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 sus recursos contenidos.

az group delete --resource-group contoso-rg

Pasos siguientes

En este inicio rápido, ha creado un recurso CCF administrado 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 estos artículos:

  • Last updated on