Dela via

Snabbstart: Skapa en Azure Managed CCF-resurs med hjälp av Azure SDK for Go

  • Artikel

Azure Managed CCF (Managed CCF) är en ny och mycket säker tjänst för att distribuera konfidentiella program. Mer information om hanterad CCF finns i Om Azure Managed Confidential Consortium Framework.

I den här snabbstarten får du lära dig hur du skapar en hanterad CCF-resurs med hjälp av Azure SDK för Go-biblioteket.

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar.

API-referensdokumentationEns källkodspaket | för bibliotek (Go) |

Förutsättningar

Konfiguration

Skapa ett nytt Go-program

  1. I ett kommandogränssnitt kör du följande kommando för att skapa en mapp med namnet managedccf-app:
mkdir managedccf-app && cd managedccf-app

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

Installera modulerna

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

För den här snabbstarten måste du också installera Azure Identity-modulen för Go.

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

Skapa en resursgrupp

En resursgrupp är en logisk container där Azure-resurser distribueras och hanteras. Använd cmdleten Azure PowerShell New-AzResourceGroup för att skapa en resursgrupp med namnet myResourceGroup på platsen southcentralus.

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

Registrera resursprovidern

Resurstypen Azure Managed CCF måste registreras i prenumerationen innan du skapar en resurs.

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

az provider register --namespace Microsoft.ConfidentialLedger

Skapa medlemmar

Generera ett nyckelpar för medlemmen. När följande kommandon har slutförts sparas medlemmens offentliga nyckel i member0_cert.pem och den privata nyckeln sparas i 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"

Skapa Go-programmet

Biblioteket för hanteringsplan tillåter åtgärder på hanterade CCF-resurser, till exempel skapande och borttagning, lista resurser som är associerade med en prenumeration och visning av information om en specifik resurs. Följande kod skapar och visar egenskaperna för en hanterad CCF-resurs.

Lägg till följande direktiv överst i 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"
)

Autentisera och skapa en klientfabrik

I den här snabbstarten används inloggad användare för att autentisera till Azure Managed CCF, vilket är den bästa metoden för lokal utveckling. I det här exemplet används klassen "NewDefaultAzureCredential()" från Azure Identity-modulen, vilket gör att du kan använda samma kod i olika miljöer med olika alternativ för att tillhandahålla identitet.

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

Skapa en Azure Resource Manager-klientfabrik och autentisera med hjälp av tokenautentiseringsuppgifterna.

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

Skapa en hanterad CCF-resurs

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

Hämta egenskaperna för den hanterade CCF-resursen

Följande kod hämtar den hanterade CCF-resursen som skapades i föregående steg.

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)

Visa en lista över hanterade CCF-resurser i en resursgrupp

Följande kod hämtar hanterade CCF-resurser i resursgruppen.

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

Ta bort den hanterade CCF-resursen

Följande kodavsnitt tar bort den hanterade CCF-resursen. Andra hanterade CCF-artiklar kan bygga vidare på den här snabbstarten. Om du planerar att fortsätta arbeta med efterföljande snabbstarter och självstudier kanske du vill lämna dessa resurser på plats.

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

Rensa resurser

Andra hanterade CCF-artiklar kan bygga vidare på den här snabbstarten. Om du planerar att fortsätta arbeta med efterföljande snabbstarter och självstudier kanske du vill lämna dessa resurser på plats.

När du är klar med resurserna som skapas i den här artikeln använder du annars kommandot Azure CLI az group delete för att ta bort resursgruppen och alla dess inneslutna resurser.

az group delete --resource-group contoso-rg

Nästa steg

I den här snabbstarten skapade du en hanterad CCF-resurs med hjälp av Azure Python SDK för konfidentiell transaktionsregister. Om du vill veta mer om Azure Managed CCF och hur du integrerar det med dina program kan du fortsätta med följande artiklar: