Rychlý start: Vytvoření prostředku AZURE Managed CCF pomocí sady Azure SDK for Go

  • Článek

Azure Managed CCF (Managed CCF) je nová a vysoce zabezpečená služba pro nasazování důvěrných aplikací. Další informace o spravované službě CCF najdete v tématu o rozhraní Spravované důvěrné konsorcium Azure.

V tomto rychlém startu se dozvíte, jak vytvořit spravovaný prostředek CCF pomocí knihovny Azure SDK for Go.

Pokud ještě nemáte předplatné Azure, vytvořte si bezplatný účet Azure před tím, než začnete.

Referenční dokumentace k | rozhraní API – Balíček zdrojového kódu | knihovny (Go)

Předpoklady

Nastavení

Vytvoření nové aplikace Go

  1. Spuštěním následujícího příkazu v příkazovém prostředí vytvořte složku s názvem managedccf-app:
mkdir managedccf-app && cd managedccf-app

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

Instalace modulů

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

Pro účely tohoto rychlého startu musíte také nainstalovat modul Azure Identity for Go.

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

Vytvoření skupiny zdrojů

Skupina prostředků je logický kontejner, ve kterém se nasazují a spravují prostředky Azure. Pomocí rutiny Azure PowerShell New-AzResourceGroup vytvořte skupinu prostředků myResourceGroup v umístění southcentralus.

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

Registrace poskytovatele prostředků

Před vytvořením prostředku musí být ve službě Azure Managed CCF zaregistrovaný v předplatném.

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

az provider register --namespace Microsoft.ConfidentialLedger

Vytvoření členů

Vygenerujte dvojici klíčů pro člena. Po dokončení následujících příkazů se veřejný klíč člena uloží a member0_cert.pem privátní klíč se uloží do member0_privk.pemsouboru .

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"

Vytvoření aplikace Go

Knihovna roviny správy umožňuje operace se spravovanými prostředky CCF, jako je vytvoření a odstranění, výpis prostředků přidružených k předplatnému a zobrazení podrobností o konkrétním prostředku. Následující část kódu vytvoří a zobrazí vlastnosti spravovaného prostředku CCF.

Na začátek souboru main.go přidejte následující direktivy:

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

Ověření a vytvoření klientské továrny

V tomto rychlém startu se přihlášený uživatel používá k ověření ve službě Azure Managed CCF, což je upřednostňovaná metoda místního vývoje. Tento příklad používá třídu NewDefaultAzureCredential() z modulu Azure Identity, která umožňuje použít stejný kód v různých prostředích s různými možnostmi pro poskytnutí identity.

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

Vytvořte objekt pro vytváření klientů Azure Resource Manageru a ověřte se pomocí přihlašovacích údajů tokenu.

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

Vytvoření spravovaného prostředku CCF

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

Získání vlastností spravovaného prostředku CCF

Následující část kódu načte spravovaný prostředek CCF vytvořený v předchozím kroku.

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)

Výpis spravovaných prostředků CCF ve skupině prostředků

Následující část kódu načte spravované prostředky CCF ve skupině prostředků.

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

Odstranění spravovaného prostředku CCF

Následující část kódu odstraní spravovaný prostředek CCF. Další články o spravovaných CCF můžou na tomto rychlém startu vycházet. Pokud chcete pokračovat v práci s dalšími rychlými starty a kurzy, možná budete chtít tyto prostředky ponechat na místě.

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

Vyčištění prostředků

Další články o spravovaných CCF můžou na tomto rychlém startu vycházet. Pokud chcete pokračovat v práci s dalšími rychlými starty a kurzy, možná budete chtít tyto prostředky ponechat na místě.

Jinak po dokončení práce s prostředky vytvořenými v tomto článku pomocí příkazu Az group delete v Azure CLI odstraňte skupinu prostředků a všechny její obsažené prostředky.

az group delete --resource-group contoso-rg

Další kroky

V tomto rychlém startu jste vytvořili spravovaný prostředek CCF pomocí sady Azure Python SDK for Confidential Ledger. Další informace o službě Azure Managed CCF a o tom, jak ji integrovat s vašimi aplikacemi, najdete v těchto článcích: