Partager via

Démarrage rapide : Créer une ressource Azure Managed CCF à l’aide du kit Azure SDK pour Go

  • Article

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

Dans ce guide de démarrage rapide, vous allez découvrir comment créer une ressource Managed CCF à l’aide de la bibliothèque du kit Azure SDK pour Go.

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

Documentation de la référence API | Code source de la bibliothèque | Package (Go)

Prérequis

Paramétrage

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 la cmdlet Azure PowerShell New-AzResourceGroup pour créer un groupe de ressources nommé myResourceGroup dans la région 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 la création d’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 la commande suivante terminée, la clé publique du membre est enregistrée dans 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 d’effectuer des opérations sur les ressources Managed CCF, par exemple les opérations de création et de suppression, le listage des ressources associées à un abonnement ainsi que l’affichage des détails d’une ressource spécifique. L’extrait de code suivant permet de créer et de visualiser les propriétés d’une ressource Managed CCF.

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 de clients

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

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

Créez une fabrique de clients Azure Resource Manager, puis 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 Managed 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)
}

Obtenir les propriétés de la ressource Managed CCF

L’extrait de code suivant récupère la ressource Managed CCF 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)

Lister les ressources Managed CCF dans un groupe de ressources

L’extrait de code suivant récupère les ressources Managed CCF 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 Managed CCF

L’extrait de code suivant supprime la ressource Managed CCF. D’autres articles consacrés à Managed CCF peuvent s’appuyer sur ce guide de démarrage rapide. Si vous prévoyez d’utiliser d’autres guides de démarrage rapide et tutoriels, vous pouvez conserver ces ressources.

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 consacrés à Managed CCF peuvent s’appuyer sur ce guide de démarrage rapide. Si vous prévoyez d’utiliser d’autres guides de démarrage rapide et tutoriels, vous pouvez conserver ces ressources.

Sinon, une fois que vous avez fini d’utiliser les ressources créées dans cet article, utilisez la commande az group delete d’Azure CLI pour supprimer le groupe de ressources et toutes les ressources qu’il contient.

az group delete --resource-group contoso-rg

Étapes suivantes

Dans ce guide de démarrage rapide, vous avez créé une ressource Managed CCF à l’aide du kit SDK Azure Python pour le registre confidentiel. Pour en savoir plus sur Azure Managed CCF et sur la façon de l’intégrer à vos applications, lisez également ces articles :