Delen via


Quickstart: Een Azure Managed CCF-resource maken met behulp van de Azure SDK voor Go

Azure Managed CCF (Managed CCF) is een nieuwe en zeer veilige service voor het implementeren van vertrouwelijke toepassingen. Zie Over Azure Managed Confidential Consortium Framework voor meer informatie over Managed CCF.

In deze quickstart leert u hoe u een beheerde CCF-resource maakt met behulp van de Azure SDK voor Go-bibliotheek.

Als u geen Azure-abonnement hebt, kunt u een gratis Azure-account maken voordat u begint.

Api-referentiedocumentatiebibliotheek | broncodepakket | (Go)

Vereisten

Instellingen

Een nieuwe Go-toepassing maken

  1. Voer in een opdrachtshell de volgende opdracht uit om een map met de naam managedccf-appte maken:
mkdir managedccf-app && cd managedccf-app

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

De modules installeren

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

Voor deze quickstart moet u ook de Azure Identity-module voor Go installeren.

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

Een brongroep maken

Een resourcegroep is een logische container waarin Azure-resources worden geïmplementeerd en beheerd. Gebruik de Azure PowerShell New-AzResourceGroup-cmdlet om een resourcegroep met de naam myResourceGroup te maken op de locatie southcentralus .

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

De resourceprovider registreren

Het azure managed CCF-resourcetype moet worden geregistreerd in het abonnement voordat u een resource maakt.

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

az provider register --namespace Microsoft.ConfidentialLedger

Leden maken

Genereer een sleutelpaar voor het lid. Nadat de volgende opdrachten zijn voltooid, wordt de openbare sleutel van het lid opgeslagen en member0_cert.pem wordt de persoonlijke sleutel opgeslagen 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"

De Go-toepassing maken

Met de beheervlakbibliotheek kunt u bewerkingen uitvoeren voor beheerde CCF-resources, zoals het maken en verwijderen, het weergeven van de resources die zijn gekoppeld aan een abonnement en het weergeven van de details van een specifieke resource. In het volgende codefragment worden de eigenschappen van een beheerde CCF-resource gemaakt en weergegeven.

Voeg de volgende instructies toe aan het begin van 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"
)

Een clientfactory verifiëren en maken

In deze quickstart wordt de aangemelde gebruiker gebruikt om te verifiëren bij Azure Managed CCF. Dit is de voorkeursmethode voor lokale ontwikkeling. In dit voorbeeld wordt de klasse 'NewDefaultAzureCredential()' van de Azure Identity-module gebruikt, waarmee dezelfde code in verschillende omgevingen met verschillende opties kan worden gebruikt om identiteit te bieden.

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

Maak een Azure Resource Manager-clientfactory en verifieer met behulp van de tokenreferentie.

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

Een beheerde CCF-resource maken

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

De eigenschappen van de beheerde CCF-resource ophalen

Met het volgende codefragment wordt de beheerde CCF-resource opgehaald die in de vorige stap is gemaakt.

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)

De beheerde CCF-resources in een resourcegroep weergeven

Met het volgende codefragment worden de beheerde CCF-resources in de resourcegroep opgehaald.

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

De beheerde CCF-resource verwijderen

Met het volgende codefragment wordt de beheerde CCF-resource verwijderd. Andere beheerde CCF-artikelen kunnen voortbouwen op deze quickstart. Als u van plan bent om door te gaan met de volgende quickstarts en zelfstudies, wilt u deze resources mogelijk behouden.

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

Resources opschonen

Andere beheerde CCF-artikelen kunnen voortbouwen op deze quickstart. Als u van plan bent om door te gaan met de volgende quickstarts en zelfstudies, wilt u deze resources mogelijk behouden.

Als u klaar bent met de resources die in dit artikel zijn gemaakt, gebruikt u de opdracht Azure CLI az group delete om de resourcegroep en alle bijbehorende resources te verwijderen.

az group delete --resource-group contoso-rg

Volgende stappen

In deze quickstart hebt u een beheerde CCF-resource gemaakt met behulp van de Azure Python SDK voor Confidential Ledger. Voor meer informatie over Azure Managed CCF en hoe u deze integreert met uw toepassingen, gaat u verder met deze artikelen: