Megosztás a következőn keresztül:

Függőséginjektálás a .NET-hez készült Azure SDK-val

  • Cikk

Ez a cikk bemutatja, hogyan regisztrálhatja az Azure-szolgáltatásügyfeleket a .NET-hez készült legújabb Azure-ügyfélkódtárakból a függőséginjektáláshoz egy .NET-alkalmazásban. Minden modern .NET-alkalmazás egy Program.cs fájlban megadott utasítások alapján indul el.

Csomagok telepítése

Szolgáltatás-ügyfelek regisztrálása és konfigurálása előtaggal Azure.rendelkező csomagból:

  1. Telepítse a Microsoft.Extensions.Azure-csomagot a projektben:

    dotnet add package Microsoft.Extensions.Azure

  2. Telepítse az Azure.Identity-csomagot úgy, hogy egy TokenCredential olyan típust konfiguráljon, amely az ilyen típust elfogadó összes regisztrált ügyfél hitelesítéséhez használható:

    dotnet add package Azure.Identity

Bemutató célokra a cikkben szereplő mintakód a Key Vault titkos kulcsait, a Blob Storage-t, a Service Bust és az Azure OpenAI-kódtárakat használja. Telepítse a következő csomagokat a következők követéséhez:

dotnet add package Azure.Security.KeyVault.Secrets
dotnet add package Azure.Storage.Blobs
dotnet add package Azure.Messaging.ServiceBus
dotnet add package Azure.AI.OpenAI

Ügyfelek és segédküldők regisztrálása

A szolgáltatásügyfél egy Azure-szolgáltatás API-jának belépési pontja – ebből a kódtár felhasználói meghívhatják a szolgáltatás által biztosított összes műveletet, és könnyen implementálhatják a leggyakoribb forgatókönyveket. Ahol egyszerűbbé válik az API kialakítása, a szolgáltatáshívások csoportjai kisebb alkonfiguráltípusok köré szervezhetők. Regisztrálhat például ServiceBusClient további ServiceBusSender alkonzisznciákat az üzenetek közzétételéhez vagy ServiceBusReceiver az üzeneteket használó alkonzisterekhez.

A Program.cs fájlban hívja meg a AddAzureClients bővítménymetódust, hogy minden szolgáltatáshoz regisztráljon egy ügyfelet. Az alábbi kódminták útmutatást nyújtanak az alkalmazáskészítők számára a névterekből és Microsoft.Extensions.Hosting a Microsoft.AspNetCore.Builder névterekből.

using Azure.Identity;
using Azure.Messaging.ServiceBus;
using Azure.Messaging.ServiceBus.Administration;
using Microsoft.Extensions.Azure;
using Azure.AI.OpenAI;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

builder.Services.AddAzureClients(async clientBuilder =>
{
    // Register clients for each service
    clientBuilder.AddSecretClient(new Uri("<key_vault_url>"));
    clientBuilder.AddBlobServiceClient(new Uri("<storage_url>"));
    clientBuilder.AddServiceBusClientWithNamespace(
        "<your_namespace>.servicebus.windows.net");

    // Set a credential for all clients to use by default
    DefaultAzureCredential credential = new();
    clientBuilder.UseCredential(credential);

    // Register a subclient for each Service Bus Queue
    List<string> queueNames = await GetQueueNames(credential);
    foreach (string queue in queueNames)
    {
        clientBuilder.AddClient<ServiceBusSender, ServiceBusClientOptions>(
            (_, _, provider) => provider.GetService<ServiceBusClient>()
                .CreateSender(queue)).WithName(queue);
    }

    // Register a custom client factory
    clientBuilder.AddClient<AzureOpenAIClient, AzureOpenAIClientOptions>(
        (options, _, _) => new AzureOpenAIClient(
            new Uri("<url_here>"), credential, options)); 
});

WebApplication app = builder.Build();

async Task<List<string>> GetQueueNames(DefaultAzureCredential credential)
{
    // Query the available queues for the Service Bus namespace.
    var adminClient = new ServiceBusAdministrationClient
        ("<your_namespace>.servicebus.windows.net", credential);
    var queueNames = new List<string>();

    // Because the result is async, the queue names need to be captured
    // to a standard list to avoid async calls when registering. Failure to
    // do so results in an error with the services collection.
    await foreach (QueueProperties queue in adminClient.GetQueuesAsync())
    {
        queueNames.Add(queue.Name);
    }

    return queueNames;
}

A fenti kód a következőket végzi el:

  • A Key Vault Titkos kulcsok, a Blob Storage és a Service Bus-ügyfelek regisztrálva vannak a , AddBlobServiceClient illetve AddServiceBusClientWithNamespacea AddSecretClient. A Uri- és stringa -typed argumentumot a rendszer átadja. Az URL-címek explicit megadásának elkerülése érdekében tekintse meg az Áruház konfigurációját a kódszakasztól elkülönítve.
  • DefaultAzureCredential az egyes regisztrált ügyfelek argumentumkövetelményének kielégítésére TokenCredential szolgál. Az egyik ügyfél létrehozásakor DefaultAzureCredential a rendszer a hitelesítésre használja.
  • A Service Bus-alkonzisok a szolgáltatás minden egyes üzenetsorához regisztrálva vannak az alkliens és a megfelelő beállítástípusok használatával. Az alkliensek üzenetsorneveit a rendszer a szolgáltatásregisztráción kívüli külön metódussal kéri le, mert a GetQueuesAsync metódust aszinkron módon kell futtatni.
  • Az Azure OpenAI-ügyfél regisztrálva van egy egyéni ügyfél-előállítóval a AddClient metóduson keresztül, amely szabályozza az ügyfélpéldányok létrehozásának módját. Az egyéni ügyfélgyárak a következő esetekben hasznosak:
    • Az ügyfélépítés során más függőségeket kell használnia.
    • A regisztrálni kívánt szolgáltatásügyfélhez nem létezik regisztrációs bővítménymetódus.

A regisztrált ügyfelek használata

Az ügyfelek regisztrálva vannak az ügyfelek regisztrálása és az alkliensek szakaszban leírtak szerint, most már használhatja őket. Az alábbi példában konstruktorinjektálást használunk a Blob Storage-ügyfél és a Service Bus-küldő alkonzis-alkonzisok beszerzéséhez egy ASP.NET Core API-vezérlőben:

[ApiController]
[Route("[controller]")]
public class MyApiController : ControllerBase
{
    private readonly BlobServiceClient _blobServiceClient;
    private readonly ServiceBusSender _serviceBusSender;
  
    public MyApiController(
        BlobServiceClient blobServiceClient,
        IAzureClientFactory<ServiceBusSender> senderFactory)
    {
        _blobServiceClient = blobServiceClient;
        _serviceBusSender = senderFactory.CreateClient("myQueueName");
    }
  
    [HttpGet]
    public async Task<IEnumerable<string>> Get()
    {
        BlobContainerClient containerClient = 
            _blobServiceClient.GetBlobContainerClient("demo");
        var results = new List<string>();

        await foreach (BlobItem blob in containerClient.GetBlobsAsync())
        {
            results.Add(blob.Name);
        }

        return results.ToArray();
    }
}

A konfiguráció tárolása a kódtól elkülönítve

Az Ügyfelek és alkonfigurációk regisztrálása szakaszban explicit módon adta át a Uri-typed változókat az ügyfélkonstruktoroknak. Ez a megközelítés problémákat okozhat, ha kódokat futtat különböző környezeteken a fejlesztés és az éles környezet során. A .NET-csapat javasolja az ilyen konfigurációk környezetfüggő JSON-fájlokban való tárolását. Használhat például egy alkalmazásbeállítást . Development.json fejlesztési környezeti beállításokat tartalmazó fájl. Egy másik alkalmazásbeállítás. Production.json fájl az éles környezet beállításait és így tovább. A fájlformátum a következő:

{
  "AzureDefaults": {
    "Diagnostics": {
      "IsTelemetryDisabled": false,
      "IsLoggingContentEnabled": true
    },
    "Retry": {
      "MaxRetries": 3,
      "Mode": "Exponential"
    }
  },
  "KeyVault": {
    "VaultUri": "https://mykeyvault.vault.azure.net"
  },
  "ServiceBus": {
    "Namespace": "<your_namespace>.servicebus.windows.net"
  },
  "Storage": {
    "ServiceUri": "https://mydemoaccount.storage.windows.net"
  }
}

Az osztály bármely ClientOptions tulajdonságát hozzáadhatja a JSON-fájlhoz. A JSON-konfigurációs fájl beállításai a következővel IConfigurationkérhetők le: .

builder.Services.AddAzureClients(clientBuilder =>
{
    clientBuilder.AddSecretClient(
        builder.Configuration.GetSection("KeyVault"));

    clientBuilder.AddBlobServiceClient(
        builder.Configuration.GetSection("Storage"));

    clientBuilder.AddServiceBusClientWithNamespace(
        builder.Configuration["ServiceBus:Namespace"]);

    clientBuilder.UseCredential(new DefaultAzureCredential());

    // Set up any default settings
    clientBuilder.ConfigureDefaults(
        builder.Configuration.GetSection("AzureDefaults"));
});

Az előző JSON-mintában:

Több különböző névvel rendelkező szolgáltatásalkalmazás konfigurálása

Tegyük fel, hogy két tárfiókja van: az egyik a privát adatokhoz, a másik pedig a nyilvános információkhoz. Az alkalmazás bizonyos műveletek után a nyilvános tárfiókba továbbítja az adatokat. Két tárolási szolgáltatás ügyfélnek kell rendelkeznie. A két ügyfél megkülönböztetéséhez használja a bővítménymetódust WithName :

builder.Services.AddAzureClients(clientBuilder =>
{
    clientBuilder.AddBlobServiceClient(
        builder.Configuration.GetSection("PublicStorage"));

    clientBuilder.AddBlobServiceClient(
            builder.Configuration.GetSection("PrivateStorage"))
        .WithName("PrivateStorage");
});

Ha például egy ASP.NET Core-vezérlőt használ, az interfész használatával érheti el a megnevezett szolgáltatásügyfélt IAzureClientFactory<TClient> :

public class HomeController : Controller
{
    private readonly BlobServiceClient _publicStorage;
    private readonly BlobServiceClient _privateStorage;

    public HomeController(
        BlobServiceClient defaultClient,
        IAzureClientFactory<BlobServiceClient> clientFactory)
    {
        _publicStorage = defaultClient;
        _privateStorage = clientFactory.CreateClient("PrivateStorage");
    }
}

A névtelen szolgáltatásügyfél továbbra is ugyanúgy érhető el, mint korábban. A nevesített ügyfelek additívak.

Új újrapróbálkozési szabályzat konfigurálása

Előfordulhat, hogy egy szolgáltatásügyfél alapértelmezett beállításait módosítani szeretné. Előfordulhat például, hogy eltérő újrapróbálkozési beállításokat szeretne használni, vagy másik szolgáltatás API-verziót szeretne használni. Az újrapróbálkozás beállításait globálisan vagy szolgáltatásonként állíthatja be. Tegyük fel, hogy a ASP.NET Core-projektben a következő appsettings.json fájl található:

{
  "AzureDefaults": {
    "Retry": {
      "maxRetries": 3
    }
  },
  "KeyVault": {
    "VaultUri": "https://mykeyvault.vault.azure.net"
  },
  "ServiceBus": {
    "Namespace": "<your_namespace>.servicebus.windows.net"
  },
  "Storage": {
    "ServiceUri": "https://store1.storage.windows.net"
  },
  "CustomStorage": {
    "ServiceUri": "https://store2.storage.windows.net"
  }
}

Az újrapróbálkoztatási szabályzatot az igényeinek megfelelően módosíthatja:

builder.Services.AddAzureClients(clientBuilder =>
{
    // Establish the global defaults
    clientBuilder.ConfigureDefaults(
        builder.Configuration.GetSection("AzureDefaults"));
    clientBuilder.UseCredential(new DefaultAzureCredential());

    // A Key Vault Secrets client using the global defaults
    clientBuilder.AddSecretClient(
        builder.Configuration.GetSection("KeyVault"));

    // A Blob Storage client with a custom retry policy
    clientBuilder.AddBlobServiceClient(
            builder.Configuration.GetSection("Storage"))
        .ConfigureOptions(options => options.Retry.MaxRetries = 10);

    clientBuilder.AddServiceBusClientWithNamespace(
            builder.Configuration["ServiceBus:Namespace"])
        .ConfigureOptions(options => options.RetryOptions.MaxRetries = 10);

    // A named storage client with a different custom retry policy
    clientBuilder.AddBlobServiceClient(
            builder.Configuration.GetSection("CustomStorage"))
        .WithName("CustomStorage")
        .ConfigureOptions(options =>
        {
            options.Retry.Mode = Azure.Core.RetryMode.Exponential;
            options.Retry.MaxRetries = 5;
            options.Retry.MaxDelay = TimeSpan.FromSeconds(120);
        });
});

Az újrapróbálkozási szabályzat felülbírálásait a appsettings.json fájlban is elhelyezheti:

{
  "KeyVault": {
    "VaultUri": "https://mykeyvault.vault.azure.net",
    "Retry": {
      "maxRetries": 10
    }
  }
}

Lásd még