Início Rápido: Criar um recurso do Azure Managed CCF usando o SDK do Azure para linguagem Go

Artigo
11/20/2023

O Azure Managed CCF (Managed CCF) é um serviço novo e altamente seguro para implantar aplicativos confidenciais. Para obter mais informações sobre o Managed CCF, confira Sobre o Azure Managed Confidential Consortium Framework.

Neste início rápido, você aprenderá a criar um recurso do Managed CCF usando a biblioteca do SDK do Azure para linguagem Go.

Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar.

Documentação de referência da API | Código-fonte da biblioteca | Pacote (Go)

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente.
Go 1.18 ou superior.
OpenSSL em um computador executando Windows ou Linux.

Instalação

Criar um aplicativo Go

Em um shell de comando, execute o seguinte comando para criar uma pasta chamada managedccf-app:

mkdir managedccf-app && cd managedccf-app

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

Instalar os módulos

Instale o módulo do Razão Confidencial do Azure.

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

Para este início rápido, você também precisa instalar o módulo de Identidade do Azure para linguagem Go.

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

Criar um grupo de recursos

Um grupo de recursos é um contêiner lógico no qual os recursos do Azure são implantados e gerenciados. Use o cmdlet New-AzResourceGroup do Azure PowerShell para criar um grupo de recursos chamado myResourceGroup na localização southcentralus.

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

Registre o provedor de recursos

O tipo de recurso do Azure Managed CCF deve ser registrado na assinatura antes de criar um recurso.

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

az provider register --namespace Microsoft.ConfidentialLedger

Criar membros

Gere um par de chaves para o membro. Após a conclusão dos comandos a seguir, a chave pública do membro é salva em member0_cert.pem e a chave privada é salva em 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"

Criar o aplicativo Go

A biblioteca do plano de gerenciamento permite operações em recursos do Managed CCF, como criação e exclusão, listando os recursos associados a uma assinatura e exibindo os detalhes de um recurso específico. A parte de código a seguir cria e exibe as propriedades de um recurso do Managed CCF.

Adicione as seguintes diretivas à parte superior 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"
)

Autenticar e criar um alocador de clientes

Neste início rápido, o usuário conectado é usado para autenticar no Azure Managed CCF, que é o método preferencial para desenvolvimento local. Este exemplo usa a classe 'NewDefaultAzureCredential()' do módulo da Identidade do Azure, que permite usar o mesmo código em diferentes ambientes com diferentes opções para fornecer identidade.

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

Crie um alocador de clientes do Azure Resource Manager e autentique-se usando a credencial de token.

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

Criar um recurso do 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)
}

Obter as propriedades do recurso do Managed CCF

O trecho de código a seguir recupera o recurso do Managed CCF criado na etapa anterior.

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)

Listar os recursos do Managed CCF em um grupo de recursos

O trecho de código a seguir recupera os recursos do Managed CCF no grupo de recursos.

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

Excluir o recurso do Managed CCF

O trecho de código a seguir exclui o recurso do Managed CCF. Outros artigos do Managed CCF podem se basear neste início rápido. Se você planeja continuar a trabalhar com os tutoriais e inícios rápidos seguintes, deixe esses recursos onde estão.

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

Limpar os recursos

Outros artigos do Managed CCF podem se basear neste início rápido. Se você planeja continuar a trabalhar com os tutoriais e inícios rápidos seguintes, deixe esses recursos onde estão.

Caso contrário, quando tiver concluído os recursos criados neste artigo, use o comando az group delete da CLI do Azure para excluir o grupo de recursos e todos os recursos que ele contém.

az group delete --resource-group contoso-rg

Próximas etapas

Neste início rápido, você criou um recurso do Managed CCF usando o SDK do Python do Azure para Razão Confidencial. Para saber mais sobre o Azure Managed CCF e como integrá-lo aos seus aplicativos, confira estes artigos:

Compartilhar via