Share via

Guida introduttiva: Creare una risorsa CCF gestita di Azure con Azure SDK per Go

  • Articolo

CCF gestito di Azure è un servizio nuovo e altamente sicuro per la distribuzione di applicazioni riservate. Per altre informazioni su Managed CCF, vedere Informazioni su Azure Managed Confidential Consortium Framework.

Questa guida introduttiva illustra come creare una risorsa CCF gestita usando la libreria Azure SDK per Go.

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

Documentazione | di riferimento sulle API Pacchetto del codice | sorgente della libreria (Go)

Prerequisiti

Configurazione

Creare una nuova applicazione Go

  1. In una shell dei comandi eseguire il comando seguente per creare una cartella denominata managedccf-app:
mkdir managedccf-app && cd managedccf-app

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

Installare i moduli

  1. Installare il modulo Azure Confidential Ledger.
go get -u github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confidentialledger/armconfidentialledger@v1.2.0-beta.1

Per questa guida introduttiva, è anche necessario installare il modulo Azure Identity per Go.

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

Creare un gruppo di risorse

Un gruppo di risorse è un contenitore logico in cui vengono distribuite e gestite le risorse di Azure. Usare il cmdlet New-AzResourceGroup di Azure PowerShell per creare un gruppo di risorse denominato myResourceGroup nella posizione southcentralus.

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

Registrare il provider di risorse

Il tipo di risorsa CCF gestito di Azure deve essere registrato nella sottoscrizione prima di creare una risorsa.

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

az provider register --namespace Microsoft.ConfidentialLedger

Creare membri

Generare una coppia di chiavi per il membro. Al termine dei comandi seguenti, la chiave pubblica del membro viene salvata in member0_cert.pem e la chiave privata viene salvata in 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"

Creare l'applicazione Go

La libreria del piano di gestione consente operazioni sulle risorse CCF gestite, ad esempio la creazione e l'eliminazione, l'elenco delle risorse associate a una sottoscrizione e la visualizzazione dei dettagli di una risorsa specifica. Il frammento di codice seguente crea e visualizza le proprietà di una risorsa CCF gestita.

Aggiungere le direttive seguenti all'inizio di 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"
)

Autenticare e creare una factory client

In questa guida introduttiva viene usato l'utente connesso per l'autenticazione in CCF gestito di Azure, che è il metodo preferito per lo sviluppo locale. Questo esempio usa la classe 'NewDefaultAzureCredential()' del modulo Azure Identity, che consente di usare lo stesso codice in ambienti diversi con diverse opzioni per fornire l'identità.

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

Creare una factory client di Azure Resource Manager ed eseguire l'autenticazione usando le credenziali 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)
}

Creare una risorsa CCF gestita

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)
}

Ottenere le proprietà della risorsa CCF gestita

Il frammento di codice seguente recupera la risorsa CCF gestita creata nel passaggio precedente.

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)

Elencare le risorse CCF gestite in un gruppo di risorse

Il frammento di codice seguente recupera le risorse CCF gestite nel gruppo di risorse.

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)
    }
}

Eliminare la risorsa CCF gestita

Il frammento di codice seguente elimina la risorsa CCF gestita. Altri articoli CCF gestiti possono basarsi su questa guida introduttiva. Se si prevede di continuare a lavorare con le guide introduttive e le esercitazioni successive, è possibile lasciare queste risorse sul posto.

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)
}

Pulire le risorse

Altri articoli CCF gestiti possono basarsi su questa guida introduttiva. Se si prevede di continuare a lavorare con le guide introduttive e le esercitazioni successive, è possibile lasciare queste risorse sul posto.

In caso contrario, al termine delle risorse create in questo articolo, usare il comando az group delete dell'interfaccia della riga di comando di Azure per eliminare il gruppo di risorse e tutte le risorse contenute.

az group delete --resource-group contoso-rg

Passaggi successivi

In questa guida introduttiva è stata creata una risorsa CCF gestita usando Azure Python SDK per Confidential Ledger. Per altre informazioni su CCF gestito di Azure e su come integrarlo con le applicazioni, continuare con questi articoli: