Schnellstart: Erstellen einer Azure Managed CCF-Ressource mit dem Azure SDK für Go

Artikel
11/20/2023

Azure Managed CCF (Managed CCF) ist ein neuer und äußerst sicherer Dienst für die Bereitstellung vertraulicher Anwendungen. Weitere Informationen zu Managed CCF finden Sie unter Informationen zum Azure Managed Confidential Consortium Framework.

In diesem Schnellstart erfahren Sie, wie Sie mithilfe der Azure SDK für Go-Bibliothek eine Managed CFF-Ressource erstellen.

Sollten Sie über kein Azure-Abonnement verfügen, können Sie zunächst ein kostenloses Azure-Konto erstellen.

API-Referenzdokumentation | Quellcode der Bibliothek | Paket (Go)

Voraussetzungen

Azure-Abonnement (kostenloses Abonnement erstellen)
Go 1.18 oder höher.
OpenSSL auf einem Computer mit Windows oder Linux.

Setup

Erstellen einer neuen Go-Anwendung

Führen Sie in einer Befehlsshell den folgenden Befehl aus, um einen Ordner namens managedccf-app zu erstellen:

mkdir managedccf-app && cd managedccf-app

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

Installieren der Module

Installieren Sie das Azure Confidential Ledger-Modul.

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

Für diese Schnellstartanleitung müssen Sie auch das Azure Identity-Modul für Go installieren.

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

Erstellen einer Ressourcengruppe

Eine Ressourcengruppe ist ein logischer Container, in dem Azure-Ressourcen bereitgestellt und verwaltet werden. Erstellen Sie mit Azure PowerShell New-AzResourceGroup-cmdlet eine Ressourcengruppe mit dem Namen myResourceGroup am Speicherort southcentralus.

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

Registrieren des Ressourcenanbieters

Der Azure Managed CCF-Ressourcentyp muss im Abonnement registriert werden, bevor eine Ressource erstellt wird.

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

az provider register --namespace Microsoft.ConfidentialLedger

Erstellen von Membern

Generieren Sie ein Schlüsselpaar für das Element. Nach Abschluss der folgenden Befehle wird der öffentliche Schlüssel des Mitglieds in member0_cert.pem gespeichert, und der private Schlüssel 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"

Erstellen der Go-Anwendung

Die Verwaltungsebenenbibliothek ermöglicht Vorgänge an Managed CCF-Ressourcen, z. B. Erstellung und Löschung, Auflisten der Ressourcen, die einem Abonnement zugeordnet sind, und Anzeigen der Details einer bestimmten Ressource. Der folgende Codeabschnitt erstellt und zeigt die Eigenschaften einer Managed CCF-Ressource an.

Fügen Sie am Anfang von main.go die folgendem Anweisungen hinzu:

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

Authentifizieren und Erstellen einer Client-Factory

In dieser Schnellstartanleitung wird der angemeldete Benutzer zum Authentifizieren bei Azure Managed CCF verwendet. Dies ist die bevorzugte Methode für die lokale Entwicklung. In diesem Beispiel wird die Klasse NewDefaultAzureCredential() aus dem Azure Identity-Modul verwendet, wodurch der gleiche Code in verschiedenen Umgebungen mit verschiedenen Optionen für die Identitätsbereitstellung verwendet werden kann.

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

Erstellen Sie eine Azure Resource Manager-Clientfactory, und authentifizieren Sie sich mithilfe der Tokenanmeldeinformationen.

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

Erstellen einer Managed CCF-Ressource

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

Abrufen der Eigenschaften der Managed CCF-Ressource

Der folgende Codeabschnitt ruft die Managed CCF-Ressource ab, die im vorherigen Schritt erstellt wurde.

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)

Auflisten der Managed CCF-Ressourcen in einer Ressourcengruppe

Der folgende Codeabschnitt ruft die Managed CCF-Ressourcen in der Ressourcengruppe ab.

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

Löschen der Managed CCF-Ressource

Der folgende Codeabschnitt löscht die Managed CCF-Ressource. Andere Managed CCF-Artikel können auf dieser Schnellstartanleitung aufbauen. Wenn Sie vorhaben, mit späteren Schnellstarts und Tutorials weiterzuarbeiten, sollten Sie diese Ressourcen beibehalten.

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

Bereinigen von Ressourcen

Andere Managed CCF-Artikel können auf dieser Schnellstartanleitung aufbauen. Wenn Sie vorhaben, mit späteren Schnellstarts und Tutorials weiterzuarbeiten, sollten Sie diese Ressourcen beibehalten.

Andernfalls, wenn Sie mit den in diesem Artikel erstellten Ressourcen fertig sind, verwenden Sie den Azure CLI-Befehl az group delete, um die Ressourcengruppe und alle darin enthaltenen Ressourcen zu löschen.

az group delete --resource-group contoso-rg

Nächste Schritte

In dieser Schnellstartanleitung haben Sie eine verwaltete CCF-Ressource mithilfe des Azure Python SDK für Confidential Ledger erstellt. Wenn Sie mehr über Azure Managed CCF erfahren möchten und darüber, wie Sie es in Ihre Anwendungen integrieren können, lesen Sie diese Artikel weiter:

Share via