Erőforrások testreszabása Azure

Ha az erőforrások hosztolásához Azure-t használ egy .NET Aspire megoldáshoz, akkor részletesen szabályozhatja ezeket az erőforrásokat. Konfigurálhatja őket, ha az alapértelmezett tulajdonságok megfelelnek az igényeinek, vagy felülbírálhatja .NET.NET Aspire az alapértelmezett értékeket a viselkedésük szabályozásához. Vizsgáljuk meg, hogyan szabhatja testre saját Azure infrastruktúráját kódból .NET Aspire.

A Azure.NET SDK biztosítja a 📦Azureszolgáltatás-specifikus NuGet-csomagot és egy sor Azure kiépítési csomagot. Ezek a Azure telepítési könyvtárak megkönnyítik a Azure infrastruktúra deklaratív módon történő, natív megadását .NET-ben. Az API-k lehetővé teszik, hogy objektumorientált infrastruktúrát írjon C#-ban, ami a Bicep-et eredményezi. Bicep egy tartományspecifikus nyelv (DSL)Azure erőforrások deklaratív üzembe helyezéséhez.

Bár manuálisan is ki lehet építeni Azure erőforrásokat, .NET Aspire leegyszerűsíti a folyamatot azáltal, hogy api-kat biztosít a Azure erőforrások kifejezéséhez. Ezek az API-k kiterjesztési módszerekként érhetők el a .NET AspireAzure hosztoló könyvtárakban, és kibővítik a IDistributedApplicationBuilder interfészt. Amikor Azure erőforrásokat ad hozzá az alkalmazás hostjához, azok implicit módon hozzáadják a megfelelő erőforrás-kezelési funkciót. Más szóval nem kell közvetlenül meghívnia a kiépítési API-kat.

Mivel a .NET Aspire modellek a Azure erőforrásokat modellezik a Azure üzemeltetési integrációkban, a Azure SDK-t használják ezeknek az erőforrásoknak a létrehozásához. Bicep-fájlok jönnek létre, amelyek meghatározzák a szükséges Azure erőforrásokat. A létrehozott Bicep-fájlok a jegyzékfájl mellett jelennek meg az alkalmazás közzétételekor.

A létrehozott Bicep-fájlok többféleképpen is befolyásolhatók:

• Azure.Ellátási testreszabás:
  • Infrastruktúra-konfigurálása: Azure erőforrás-infrastruktúra testreszabása.
  • Azure infrastruktúra hozzáadása: A Azure infrastruktúra manuális hozzáadása az alkalmazáshostjához.
• Egyéni Bicep-sablonok alkalmazása:
  • Bicep fájl referenciák: Hivatkozás hozzáadása a lemezen lévő Bicep-fájlhoz.
  • Bicep inline hivatkozás: Adj hozzá egy beágyazott Bicep-sablont.

Helyi szolgáltatás biztosítása és Azure.Provisioning

A terminológiai összemosás elkerülése és a "kiépítés" egyértelműsítése érdekében fontos tisztában lenni a helyi kiépítés és a Azure kiépítésközötti különbségtétellel.

• Helyi kiépítés:

  Ha a Azure integrációs API-k bármelyikét meghívja Azure erőforrások hozzáadásához, a AddAzureProvisioning(IDistributedApplicationBuilder) API implicit módon lesz meghívva. Ez az API azokat a szolgáltatásokat regisztrálja a függőséginjektálási (DI) tárolóban, amelyeket a Azure erőforrások kiépítése során használnak, amikor az alkalmazásgazda elindul. Ezt a fogalmat helyi biztosításnéven nevezzük. További információkért lásd: Helyi Azure provízió.

• Azure.Provisioning:

  Azure.Provisioning a NuGet-csomagra hivatkozik, és olyan kódtárak készlete, amelyek lehetővé teszi a C# használatát a Bicep létrehozásához. A Azure tárhely-integrációk a .NET Aspire-ben ezeket a könyvtárakat használják a háttérben, hogy olyan Bicep-fájlokat hozzanak létre, amelyek meghatározzák a szükséges Azure erőforrásokat. További információért tekintse meg a Azure.Provisioning testreszabási-t.

Azure.Provisioning testreszabás

Minden .NET AspireAzure üzemeltetési integráció különböző Azure erőforrásokat tesz elérhetővé, és ezek mind a AzureProvisioningResource típusú alosztályok, amelyek maguk öröklik a AzureBicepResource. Ez lehetővé teszi az ilyen típusú, általánosan korlátozott bővítmények használatát, így a fluent API-k tetszés szerint testre szabhatják az infrastruktúrát. Bár .NET.NET Aspire alapértelmezett beállításokat biztosít, szabadon befolyásolhatja a létrehozott Bicep-et ezekkel az API-kkal.

Infrastruktúra konfigurálása

Függetlenül attól, hogy milyen Azure erőforrással dolgozik, a mögöttes infrastruktúra konfigurálásához a ConfigureInfrastructure bővítménymetódushoz kell láncolnia a hívást. Ezzel a módszerrel testre szabhatja az Azure erőforrás infrastruktúráját egy configureAction<AzureResourceInfrastructure>típusú delegált átadásával. A AzureResourceInfrastructure típus a Azure.Provisioning.Infrastructurealosztálya. Ez a típus egy hatalmas API-felületet tesz elérhetővé a Azure erőforrás mögöttes infrastruktúrájának konfigurálásához.

Vegye figyelembe a következő példát:

var sku = builder.AddParameter("storage-sku");

var storage = builder.AddAzureStorage("storage")
    .ConfigureInfrastructure(infra =>
    {
        var resources = infra.GetProvisionableResources();

        var storageAccount = resources.OfType<StorageAccount>().Single();

        storageAccount.Sku = new StorageSku
        {
            Name = sku.AsProvisioningParameter(infra)
        };
    });

Az előző kód:

• Hozzáad egy storage-skunevű paramétert.
• Hozzáadja a Azure Storage-t a AddAzureStorage API-hoz, amely storagenévre hallgat.
• A ConfigureInfrastructure-hez láncolt hívásokkal testreszabhatja a Azure tárhely-infrastruktúrát.
  • Lekérdezi a rendelkezésre bocsátható erőforrásokat.
  • Egyetlen StorageAccount-ra szűr.
  • Hozzárendeli a storage-sku paramétert a StorageAccount.Sku tulajdonsághoz:
    • A StorageSku új példányának Name tulajdonságát a AsProvisioningParameter API eredményéből rendelik hozzá.

Ez a példa egy külső paraméter a Azure Storage-infrastruktúrába való áramlását szemlélteti, így a létrehozott Bicep-fájl tükrözi a kívánt konfigurációt.

Adjunk hozzá Azure infrastruktúrát

Nem minden Azure szolgáltatás érhető el .NET Aspire integrációként. Bár lehetséges, hogy később válnak elérhetővé, továbbra is biztosíthatja a Azure.Provisioning.* könyvtárakban elérhető szolgáltatásokat. Képzeljen el egy olyan forgatókönyvet, amelyben egy munkafolyamat szolgáltatás felelős egy Azure Konténer-regiszter kezeléséért. Képzelje el, hogy egy alkalmazásgazda projekt függőséget vesz fel a 📦Azure.Provisioning.ContainerRegistry NuGet-csomagra.

A AddAzureInfrastructure API-val hozzáadhatja a Azure Container Registry-infrastruktúrát az alkalmazásgazda számára:

var acr = builder.AddAzureInfrastructure("acr", infra =>
{
    var registry = new ContainerRegistryService("acr")
    {
        Sku = new()
        {
            Name = ContainerRegistrySkuName.Standard
        },
    };
    infra.Add(registry);

    var output = new ProvisioningOutput("registryName", typeof(string))
    {
        Value = registry.Name
    };
    infra.Add(output);
});

builder.AddProject<Projects.WorkerService>("worker")
       .WithEnvironment(
            "ACR_REGISTRY_NAME",
            new BicepOutputReference("registryName", acr.Resource));

Az előző kód:

• AddAzureInfrastructure hívása egy acr névvel.
• Egy configureInfrastructure delegáltat biztosít a Azure Container Registry-infrastruktúra testreszabásához:
  • Létrehoz egy ContainerRegistryService objektumot a(z) acr névvel és egy standard SKU-val.
  • Hozzáadja a Azure Container Registry szolgáltatást a infra változóhoz.
  • Létrehoz egy ProvisioningOutput a névvel registryName, a típusával string, és egy értékkel, amely megfelel a Azure tárolóregisztrációs nevének.
  • Hozzáadja a kimenetet a infra változóhoz.
• Hozzáad egy worker nevű projektet az építőhöz.
• Összekapcsol egy hívást a WithEnvironment-val, hogy a projekt ACR_REGISTRY_NAME környezeti változóját a registryName kimenetének értékére állítsa.

A funkció bemutatja, hogyan adhat hozzá Azure infrastruktúrát az alkalmazásgazdaprojekthez, még akkor is, ha a Azure szolgáltatás nem érhető el közvetlenül .NET Aspire integrációként. Azt is bemutatja, hogyan áramolhat a Azure Tárolóregisztrációs adatbázis kimenete egy függő projekt környezetébe.

Fontolja meg az eredményként kapott Bicep-fájlt:

@description('The location for the resource(s) to be deployed.')
param location string = resourceGroup().location

resource acr 'Microsoft.ContainerRegistry/registries@2023-07-01' = {
  name: take('acr${uniqueString(resourceGroup().id)}', 50)
  location: location
  sku: {
    name: 'Standard'
  }
}

output registryName string = acr.name

A Bicep-fájl az Azure API által meghatározott AddAzureInfrastructure Container Registry kívánt konfigurációját tükrözi.

Bicep egyéni sablonok használata

Amikor a Azure-t kívánt felhőszolgáltatóként választja ki, az infrastruktúrát kódként definiálhatja a Bicep használatával. Célja, hogy drasztikusan leegyszerűsítse a szerzői élményt egy tisztább szintaxissal, és jobban támogassa a modularitást és a kód újrafelhasználását.

Bár .NET.NET Aspire előre összeállított Bicep-sablonokat biztosít, előfordulhat, hogy testre szeretné szabni a sablonokat, vagy sajátot szeretne létrehozni. Ez a szakasz ismerteti a Bicep-sablonok testreszabásához használható fogalmakat és a hozzájuk tartozó API-kat.

Fontos

Ez a szakasz nem a Bicep tanítására szolgál, hanem útmutatást ad arra, hogyan lehet egyéni Bicep-sablonokat létrehozni a .NET.NET Aspirehasználatához.

A üzembe helyezési történetének részeként a () a projekt megértését és a üzembe helyezésének lehetőségét biztosítja. A azd parancssori felület a Bicep-sablonok segítségével telepíti az alkalmazást Azure-re.

Aspire.Hosting.Azure csomag telepítése

Ha Bicep-fájlokra szeretne hivatkozni, lehetséges, hogy nem használja a Azure hosting-integrációkat. Ebben az esetben továbbra is hivatkozhat Bicep-fájlokra a Aspire.Hosting.Azure csomag telepítésével. Ez a csomag biztosítja a Bicep-fájlok hivatkozásához és a Azure erőforrások testreszabásához szükséges API-kat.

Jótanács

Ha valamelyik Azure üzemeltetési integrációt használja, akkor nem kell telepítenie a Aspire.Hosting.Azure csomagot, mivel az átmeneti függőség.

Ezen funkciók bármelyikének használatához a 📦Aspire.Hosting.Azure NuGet-csomagot telepíteni kell:

.NET CLI

dotnet add package Aspire.Hosting.Azure

PackageReference

<PackageReference Include="Aspire.Hosting.Azure"
                  Version="*" />

További információért lásd: dotnet add package vagy Csomagfüggőségek kezelése a .NET alkalmazásokban.

Mit várhatunk a példáktól?

Az ebben a szakaszban szereplő összes példa feltételezi, hogy a Aspire.Hosting.Azure névteret használja. Ezenkívül a példák feltételezik, hogy van egy IDistributedApplicationBuilder példányod.

using Aspire.Hosting.Azure;

var builder = DistributedApplication.CreateBuilder(args);

// Examples go here...

builder.Build().Run();

Alapértelmezés szerint a Bicep-hez kapcsolódó bármely API meghívásakor automatikusan egy olyan AddAzureProvisioning hívást is kezdeményez a rendszer, amely támogatást nyújt a Azure erőforrások dinamikus létrehozásához az alkalmazás indításakor. További információkért lásd: Helyi előkészítés és Azure.Provisioning.

Hivatkozás Bicep-fájlokra

Tegyük fel, hogy egy storage.bicep nevű fájlban van egy Bicep-sablon, amely egy Azure Storage-fiókot helyez üzembe:

param location string = resourceGroup().location
param storageAccountName string = 'toylaunch${uniqueString(resourceGroup().id)}'

resource storageAccount 'Microsoft.Storage/storageAccounts@2021-06-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
  properties: {
    accessTier: 'Hot'
  }
}

Ha a lemezen lévő Bicep-fájlra szeretne hivatkozni, hívja meg a AddBicepTemplate metódust. Vegye figyelembe a következő példát:

builder.AddBicepTemplate(
    name: "storage",
    bicepFile: "../infra/storage.bicep");

Az előző kód egy ../infra/storage.bicephelyen található Bicep-fájlra mutató hivatkozást ad hozzá. A fájl elérési útjainak relatívnak kell lenniük a alkalmazáshoz kapcsolódó projekthez viszonyítva. Ez a hivatkozás hozzáad egy AzureBicepResource-t az alkalmazás erőforrásgyűjteményéhez a "storage" névvel, és az API visszaad egy IResourceBuilder<AzureBicepResource> példányt, amely az erőforrás további testreszabására használható.

Bicep referencia soron belül

Bár a leggyakoribb forgatókönyv a Bicep-fájl lemezen való használata, a Bicep-sablonokat beágyazottan is hozzáadhatja. A beágyazott sablonok akkor lehetnek hasznosak, ha egy sablont kódban szeretne definiálni, vagy ha dinamikusan szeretné létrehozni a sablont. Beágyazott Bicep-sablon hozzáadásához hívja meg a AddBicepTemplateString metódust a Bicep-sablont megadva string-ként. Vegye figyelembe a következő példát:

builder.AddBicepTemplateString(
        name: "ai",
        bicepContent: """
        @description('That name is the name of our application.')
        param cognitiveServiceName string = 'CognitiveService-${uniqueString(resourceGroup().id)}'

        @description('Location for all resources.')
        param location string = resourceGroup().location

        @allowed([
          'S0'
        ])
        param sku string = 'S0'

        resource cognitiveService 'Microsoft.CognitiveServices/accounts@2021-10-01' = {
          name: cognitiveServiceName
          location: location
          sku: {
            name: sku
          }
          kind: 'CognitiveServices'
          properties: {
            apiProperties: {
              statisticsEnabled: false
            }
          }
        }
        """
    );

Ebben a példában a Bicep-sablon beágyazott string sablonként van definiálva, és az alkalmazás erőforrásgyűjteményéhez "ai"néven hozzáadódik. Ez a példa biztosít egy Azure AI-erőforrást.

Paraméterek átadása Bicep-sablonoknak

Bicep támogatja aparaméterek elfogadását, amelyek a sablon viselkedésének testreszabására használhatók. Ha paramétereket szeretne átadni egy Bicep-sablonnak a .NET.NET Aspire-ből, kapcsolja össze a hívásokat a WithParameter módszerhez az alábbi példában látható módon.

var region = builder.AddParameter("region");

builder.AddBicepTemplate("storage", "../infra/storage.bicep")
       .WithParameter("region", region)
       .WithParameter("storageName", "app-storage")
       .WithParameter("tags", ["latest","dev"]);

Az előző kód:

• Hozzáad egy "region" nevű paramétert a builder-példányhoz.
• A ../infra/storage.bicephelyen található Bicep-fájlra mutató hivatkozást ad hozzá.
• Átadja a "region" paramétert a Bicep-sablonnak, amely a standard paraméterértékeléssel kerül meghatározásra.
• Átadja a "storageName" paramétert a Bicep-sablonnak egy rögzített értékkel.
• A "tags" paramétert sztringtömbbel továbbítja a Bicep-sablonnak.

További információ: Külső paraméterek.

Jól ismert paraméterek

.NET .NET Aspire számos jól ismert paramétert biztosít, amelyek átadhatók a Bicep-sablonoknak. Ezek a paraméterek az alkalmazással és a környezettel kapcsolatos információk megadására szolgálnak a Bicep-sablonok számára. A következő jól ismert paraméterek érhetők el:

szakterület	Leírás	Érték
AzureBicepResource.KnownParameters.KeyVaultName	A kulcstár erőforrás neve, amelyet titkos kimenetek tárolására használnak.	"keyVaultName"
AzureBicepResource.KnownParameters.Location	Az erőforrás helye. Ez minden erőforráshoz szükséges.	"location"
AzureBicepResource.KnownParameters.LogAnalyticsWorkspaceId	A Log Analytics-munkaterület erőforrás-azonosítója.	"logAnalyticsWorkspaceId"
AzureBicepResource.KnownParameters.PrincipalId	Az aktuális felhasználó vagy felügyelt identitás fő azonosítója.	"principalId"
AzureBicepResource.KnownParameters.PrincipalName	Az aktuális felhasználó vagy felügyelt identitás elsődleges neve.	"principalName"
AzureBicepResource.KnownParameters.PrincipalType	Az aktuális felhasználó vagy felügyelt identitás elsődleges típusa. Vagy User vagy ServicePrincipal.	"principalType"

Egy jól ismert paraméter használatához adja meg a paraméter nevét a WithParameter metódusnak, például WithParameter(AzureBicepResource.KnownParameters.KeyVaultName). Nem adja át a jól ismert paraméterek értékeit, mivel .NET.NET Aspire az Ön nevében oldja fel őket.

Vegyünk egy példát, ahol egy Azure Event Grid-webhookot szeretne beállítani. A Bicep-sablont a következőképpen határozhatja meg:

param topicName string
param webHookEndpoint string
param principalId string
param principalType string
param location string = resourceGroup().location

// The topic name must be unique because it's represented by a DNS entry. 
// must be between 3-50 characters and contain only values a-z, A-Z, 0-9, and "-".

resource topic 'Microsoft.EventGrid/topics@2023-12-15-preview' = {
  name: toLower(take('${topicName}${uniqueString(resourceGroup().id)}', 50))
  location: location

  resource eventSubscription 'eventSubscriptions' = {
    name: 'customSub'
    properties: {
      destination: {
        endpointType: 'WebHook'
        properties: {
          endpointUrl: webHookEndpoint
        }
      }
    }
  }
}

resource EventGridRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(topic.id, principalId, subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'd5a91429-5739-47e2-a06b-3470a27159e7'))
  scope: topic
  properties: {
    principalId: principalId
    principalType: principalType
    roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'd5a91429-5739-47e2-a06b-3470a27159e7')
  }
}

output endpoint string = topic.properties.endpoint

Ez a Bicep-sablon számos paramétert határoz meg, beleértve a topicName, webHookEndpoint, principalId, principalTypeés az opcionális location. Ha ezeket a paramétereket a Bicep-sablonnak szeretné átadni, használja a következő kódrészletet:

var webHookApi = builder.AddProject<Projects.WebHook_Api>("webhook-api");

var webHookEndpointExpression = ReferenceExpression.Create(
        $"{webHookApi.GetEndpoint("https")}/hook");

builder.AddBicepTemplate("event-grid-webhook", "../infra/event-grid-webhook.bicep")
       .WithParameter("topicName", "events")
       .WithParameter(AzureBicepResource.KnownParameters.PrincipalId)
       .WithParameter(AzureBicepResource.KnownParameters.PrincipalType)
       .WithParameter("webHookEndpoint", () => webHookEndpointExpression);

• A webHookApi projekt a builderhivatkozásaként lesz hozzáadva.
• A topicName paraméter egy rögzített névértéket ad át.
• A webHookEndpoint paraméter olyan kifejezésként adódik át, amely meghatározza az URL-címet a api projekthivatkozások "https" végpontjáról a /hook útvonallal.
• A principalId és principalType paraméterek jól ismert paraméterekként lesznek átadva.

A jól ismert paraméterek konvencióalapúak, és az WithParameter API-val való átadáskor nem szabad megfelelő értékkel kiegészíteni. A jól ismert paraméterek leegyszerűsítenek néhány gyakori funkciót, például szerepkör-hozzárendeléseket, amikor hozzáadják a Bicep-sablonokhoz, ahogy az előző példában is látható. Szerepkör-hozzárendelésekre van szükség ahhoz, hogy az Event Grid webhook eseményeket küldjön a megadott végpontra. További információért lásd: Event Grid-adatküldő szerepkör-hozzárendelés.

Eredmények lekérése a Bicep-hivatkozásokból

A paraméterek Bicep-sablonoknak való átadása mellett kimeneteket is lekérhet a Bicep-sablonokból. Vegye figyelembe a következő Bicep-sablont, amely egy outputnevű endpoint-t definiál:

param storageName string
param location string = resourceGroup().location

resource myStorageAccount 'Microsoft.Storage/storageAccounts@2019-06-01' = {
  name: storageName
  location: location
  kind: 'StorageV2'
  sku:{
    name:'Standard_LRS'
    tier: 'Standard'
  }
  properties: {
    accessTier: 'Hot'
  }
}

output endpoint string = myStorageAccount.properties.primaryEndpoints.blob

A Bicep egy endpointnevű kimenetet határoz meg. A Bicep-sablon kimenetének lekéréséhez hívja meg a GetOutput metódust egy IResourceBuilder<AzureBicepResource>-példányon a következő C#-kódrészletben látható módon:

var storage = builder.AddBicepTemplate(
        name: "storage",
        bicepFile: "../infra/storage.bicep"
    );

var endpoint = storage.GetOutput("endpoint");

Ebben a példában a Bicep-sablon kimenete egy endpoint változóban lesz lekérve és tárolva. Ezt a kimenetet általában környezeti változóként adná át egy másik, rá támaszkodó erőforrásnak. Ha például egy ASP.NET Core Minimális API-projektje volt, amely a végponttól függött, a kimenetet környezeti változóként továbbíthatja a projektnek a következő kódrészlet használatával:

var storage = builder.AddBicepTemplate(
                name: "storage",
                bicepFile: "../infra/storage.bicep"
            );

var endpoint = storage.GetOutput("endpoint");

var apiService = builder.AddProject<Projects.AspireSample_ApiService>(
        name: "apiservice"
    )
    .WithEnvironment("STORAGE_ENDPOINT", endpoint);

További információért lásd: Bicep-kimenetek.

Titkos kódkimenetek lekérése Bicep-hivatkozásokból

A Bicep használatakor fontos, hogy kerülje a titkos adatok kimenetét. Ha egy kimenetet titkosnak tartunk, ami azt jelenti, hogy nem szabad naplókban vagy más helyeken elérhetővé tenni, akkor ennek megfelelően kell kezelni. Ez úgy érhető el, hogy a titkos kulcsot a Azure Key Vault tárolja, és a Bicep-sablonban hivatkozik rá. .NET Aspire Azure integrációja mintát biztosít a Bicep sablonból származó kimenetek biztonságos tárolásához azáltal, hogy lehetővé teszi az erőforrások számára, hogy a keyVaultName paraméterrel titkokat tároljanak Azure Key Vault-on.

Tekintsük példaként a következő Bicep-sablont, amely a titkos kódok kimenetének biztonságossá tételének fogalmát mutatja be:

param databaseAccountName string
param keyVaultName string

param databases array = []

@description('Tags that will be applied to all resources')
param tags object = {}

param location string = resourceGroup().location

var resourceToken = uniqueString(resourceGroup().id)

resource cosmosDb 'Microsoft.DocumentDB/databaseAccounts@2023-04-15' = {
    name: replace('${databaseAccountName}-${resourceToken}', '-', '')
    location: location
    kind: 'GlobalDocumentDB'
    tags: tags
    properties: {
        consistencyPolicy: { defaultConsistencyLevel: 'Session' }
        locations: [
            {
                locationName: location
                failoverPriority: 0
            }
        ]
        databaseAccountOfferType: 'Standard'
    }

    resource db 'sqlDatabases@2023-04-15' = [for name in databases: {
        name: '${name}'
        location: location
        tags: tags
        properties: {
            resource: {
                id: '${name}'
            }
        }
    }]
}

var primaryMasterKey = cosmosDb.listKeys(cosmosDb.apiVersion).primaryMasterKey

resource vault 'Microsoft.KeyVault/vaults@2023-07-01' existing = {
    name: keyVaultName

    resource secret 'secrets@2023-07-01' = {
        name: 'connectionString'
        properties: {
            value: 'AccountEndpoint=${cosmosDb.properties.documentEndpoint};AccountKey=${primaryMasterKey}'
        }
    }
}

Az előző Bicep-sablon számos más paraméter mellett egy keyVaultName paramétert vár. Ezután definiál egy Azure Cosmos DB erőforrást, és egy titkot helyez el Azure Key Vault-be, connectionString néven, amely a Cosmos DB-példányhoz tartozó teljes kapcsolati karakterláncot jelöli. A titkos kapcsolati sztring értékének eléréséhez használja a következő kódrészletet:

var cosmos = builder.AddBicepTemplate("cosmos", "../infra/cosmosdb.bicep")
    .WithParameter("databaseAccountName", "fallout-db")
    .WithParameter(AzureBicepResource.KnownParameters.KeyVaultName)
    .WithParameter("databases", ["vault-33", "vault-111"]);

var connectionString =
    cosmos.GetSecretOutput("connectionString");

builder.AddProject<Projects.WebHook_Api>("api")
    .WithEnvironment(
        "ConnectionStrings__cosmos",
        connectionString);

Az előző kódrészletben a cosmos Bicep-sablon a builderhivatkozásaként lesz hozzáadva. A connectionString titkos kimenet kibontása a Bicep-sablonból történik, és egy változóba kerül tárolásra. A titkos kimenet ezután környezeti változóként (ConnectionStrings__cosmos) továbbítja a api projektnek. Ez a környezeti változó a Cosmos DB-példányhoz való csatlakozásra szolgál.

Amikor az erőforrás üzembe van helyezve, az alapjául szolgáló telepítési mechanizmus automatikusan hivatkozik a titkos kulcsokra Azure Key Vault. A titkos kódok elkülönítésének garantálása érdekében .NET.NET Aspire forrásonként létrehoz egy Key Vaultot.

Megjegyzés:

helyi kiépítési módban a titok ki lesz nyerve a Key Vaultból, és beállításra kerül egy környezeti változóban. További információkért lásd: Helyi Azure provízió.