Partager via

Démarrage rapide : Créer une ressource Azure Managed CCF à l’aide du Kit de développement logiciel (SDK) Azure pour Go

Azure Managed CCF (Managed CCF) est un service nouveau et hautement sécurisé pour le déploiement d’applications confidentielles. Pour plus d’informations sur Managed CCF, consultez About Azure Managed Confidential Consortium Framework.

Dans ce guide de démarrage rapide, vous allez apprendre à créer une ressource CCF managée à l’aide de la bibliothèque Azure SDK pour Go.

Si vous n’avez pas de compte Azure, créez un compte gratuit avant de commencer.

Documentation de | référence sur l’APICode | source de la bibliothèquePackage (Go)

Prerequisites

Coup monté

Créer une application Go

  1. Dans un interpréteur de commandes, exécutez la commande suivante pour créer un dossier nommé managedccf-app:
mkdir managedccf-app && cd managedccf-app

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

Installer les modules

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

Pour ce guide de démarrage rapide, vous devez également installer le module Azure Identity pour Go.

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

Créer un groupe de ressources

Un groupe de ressources est un conteneur logique dans lequel les ressources Azure sont déployées et gérées. Utilisez l’applet de commande Azure PowerShell New-AzResourceGroup pour créer un groupe de ressources nommé myResourceGroup à l’emplacement southcentralus .

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

Inscrire le fournisseur de ressources

Le type de ressource Azure Managed CCF doit être inscrit dans l’abonnement avant de créer une ressource.

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

az provider register --namespace Microsoft.ConfidentialLedger

Créer des membres

Générez une paire de clés pour le membre. Une fois les commandes suivantes terminées, la clé publique du membre est enregistrée member0_cert.pem et la clé privée est enregistrée dans 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"

Créer l’application Go

La bibliothèque de plan de gestion permet des opérations sur des ressources CCF gérées, telles que la création et la suppression, la liste des ressources associées à un abonnement et l’affichage des détails d’une ressource spécifique. L’élément de code suivant crée et affiche les propriétés d’une ressource CCF managée.

Ajoutez les directives suivantes en haut de 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"
)

Authentifier et créer une fabrique cliente

Dans ce guide de démarrage rapide, l’utilisateur connecté est utilisé pour s’authentifier auprès d’Azure Managed CCF, qui est la méthode préférée pour le développement local. Cet exemple utilise la classe « NewDefaultAzureCredential() » à partir du module Azure Identity, qui permet d’utiliser le même code dans différents environnements avec différentes options pour fournir une identité.

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

Créez une fabrique de client Azure Resource Manager et authentifiez-vous à l’aide des informations d’identification du jeton.

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

Créer une ressource CCF managée

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

Obtenir les propriétés de la ressource CCF gérée

L’élément de code suivant récupère la ressource CCF managée créée à l’étape précédente.

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)

Répertorier les ressources CCF gérées dans un groupe de ressources

L’élément de code suivant récupère les ressources CCF gérées dans le groupe de ressources.

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

Supprimer la ressource CCF gérée

L’élément de code suivant supprime la ressource CCF gérée. D’autres articles de CCF managés peuvent s’appuyer sur ce guide de démarrage rapide. Si vous envisagez de continuer à travailler avec des guides de démarrage rapide et des didacticiels suivants, vous souhaiterez peut-être laisser ces ressources en place.

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

Nettoyer les ressources

D’autres articles de CCF managés peuvent s’appuyer sur ce guide de démarrage rapide. Si vous envisagez de continuer à travailler avec des guides de démarrage rapide et des didacticiels suivants, vous souhaiterez peut-être laisser ces ressources en place.

Sinon, lorsque vous avez terminé d’utiliser les ressources créées dans cet article, utilisez la commande Azure CLI az group delete pour supprimer le groupe de ressources et toutes ses ressources contenues.

az group delete --resource-group contoso-rg

Étapes suivantes

Dans ce guide de démarrage rapide, vous avez créé une ressource CCF managée à l’aide du Kit de développement logiciel (SDK) Azure Python pour le registre confidentiel. Pour en savoir plus sur Azure Managed CCF et comment l’intégrer à vos applications, passez à ces articles :

  • Last updated on