Udostępnij za pośrednictwem

Szybki start: tworzenie zasobu CCF zarządzanego przez platformę Azure przy użyciu zestawu Azure SDK dla języka Go

  • Artykuł

Azure Managed CCF (Managed CCF) to nowa i wysoce bezpieczna usługa do wdrażania aplikacji poufnych. Aby uzyskać więcej informacji na temat zarządzanego programu CCF, zobacz About Azure Managed Confidential Consortium Framework (Informacje o platformie Azure Managed Confidential Consortium Framework).

Z tego przewodnika Szybki start dowiesz się, jak utworzyć zasób zarządzanego programu CCF przy użyciu biblioteki zestawu Azure SDK dla języka Go.

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure.

Dokumentacja interfejsu API — pakiet | kodu | źródłowego biblioteki (Go)

Wymagania wstępne

Ustawienia

Tworzenie nowej aplikacji języka Go

  1. W powłoce poleceń uruchom następujące polecenie, aby utworzyć folder o nazwie managedccf-app:
mkdir managedccf-app && cd managedccf-app

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

Instalacja modułów

  1. Zainstaluj moduł Poufne rejestry platformy Azure.
go get -u github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/confidentialledger/armconfidentialledger@v1.2.0-beta.1

W tym przewodniku Szybki start musisz również zainstalować moduł Azure Identity dla języka Go.

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

Tworzenie grupy zasobów

Grupa zasobów to logiczny kontener przeznaczony do wdrażania zasobów platformy Azure i zarządzania nimi. Użyj polecenia cmdlet New-AzResourceGroup programu Azure PowerShell, aby utworzyć grupę zasobów o nazwie myResourceGroup w lokalizacji southcentralus.

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

Rejestrowanie dostawcy zasobów

Przed utworzeniem zasobu należy zarejestrować typ zasobu CCF zarządzanego przez platformę Azure w ramach subskrypcji.

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

az provider register --namespace Microsoft.ConfidentialLedger

Tworzenie członków

Wygeneruj parę kluczy dla elementu członkowskiego. Po zakończeniu wykonywania poniższych poleceń klucz publiczny członka jest zapisywany w member0_cert.pem pliku i klucz prywatny jest zapisywany w pliku 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"

Tworzenie aplikacji języka Go

Biblioteka płaszczyzn zarządzania umożliwia wykonywanie operacji na zarządzanych zasobach CCF, takich jak tworzenie i usuwanie, wyświetlanie listy zasobów skojarzonych z subskrypcją oraz wyświetlanie szczegółów określonego zasobu. Poniższy fragment kodu tworzy i wyświetla właściwości zarządzanego zasobu CCF.

Dodaj następujące dyrektywy na początku pliku 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"
)

Uwierzytelnianie i tworzenie fabryki klienta

W tym przewodniku Szybki start zalogowany użytkownik jest używany do uwierzytelniania w usłudze Azure Managed CCF, która jest preferowaną metodą programowania lokalnego. W tym przykładzie użyto klasy "NewDefaultAzureCredential()" z modułu Azure Identity, która umożliwia używanie tego samego kodu w różnych środowiskach z różnymi opcjami w celu zapewnienia tożsamości.

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

Utwórz fabrykę klienta usługi Azure Resource Manager i uwierzytelnij się przy użyciu poświadczeń 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)
}

Tworzenie zarządzanego zasobu 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)
}

Pobieranie właściwości zarządzanego zasobu CCF

Poniższy fragment kodu pobiera zasób managed CCF utworzony w poprzednim 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)

Wyświetlanie listy zarządzanych zasobów CCF w grupie zasobów

Poniższy fragment kodu pobiera zarządzane zasoby CCF w grupie zasobów.

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

Usuwanie zarządzanego zasobu CCF

Poniższy fragment kodu usuwa zarządzany zasób CCF. Inne artykuły dotyczące zarządzanego programu CCF mogą opierać się na tym przewodniku Szybki start. Jeśli planujesz kontynuować pracę z kolejnymi przewodnikami Szybki start i samouczkami, możesz pozostawić te zasoby na miejscu.

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

Czyszczenie zasobów

Inne artykuły dotyczące zarządzanego programu CCF mogą opierać się na tym przewodniku Szybki start. Jeśli planujesz kontynuować pracę z kolejnymi przewodnikami Szybki start i samouczkami, możesz pozostawić te zasoby na miejscu.

W przeciwnym razie po zakończeniu pracy z zasobami utworzonymi w tym artykule użyj polecenia az group delete interfejsu wiersza polecenia platformy Azure, aby usunąć grupę zasobów i wszystkie zawarte w niej zasoby.

az group delete --resource-group contoso-rg

Następne kroki

W tym przewodniku Szybki start utworzono zasób zarządzanego programu CCF przy użyciu zestawu Azure Python SDK for Confidential Ledger. Aby dowiedzieć się więcej o usłudze Azure Managed CCF i sposobie jej integracji z aplikacjami, przejdź do następujących artykułów: