Sdílet prostřednictvím

Injektáž závislostí pomocí sady Azure SDK pro .NET

Tento článek ukazuje, jak zaregistrovat klienty služeb Azure z nejnovějších klientských knihoven Azure pro .NET pro injektáž závislostí v aplikaci .NET. Každá moderní aplikace .NET se spustí podle pokynů uvedených v souboru Program.cs .

Instalace balíčků

Registrace a konfigurace klientů služby z balíčkuAzure.

  1. Nainstalujte balíček Microsoft.Extensions.Azure do projektu:

    dotnet add package Microsoft.Extensions.Azure

  2. Nainstalujte balíček Azure.Identity a nakonfigurujte TokenCredential typ, který se má použít pro ověřování všech registrovaných klientů, kteří takový typ přijímají:

    dotnet add package Azure.Identity

Ukázkový kód v tomto článku pro demonstrační účely používá tajné kódy služby Key Vault, blob Storage, Service Bus a knihovny Azure OpenAI. Nainstalujte následující balíčky, abyste mohli postupovat podle následujících kroků:

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

Registrace klientů a dílčích klientů

Klient služby je vstupním bodem rozhraní API pro službu Azure – z ní můžou uživatelé knihovny vyvolat všechny operace, které služba poskytuje, a mohou snadno implementovat nejběžnější scénáře. Když návrh rozhraní API zjednodušíte, dají se skupiny volání služeb uspořádat kolem menších typů dílčích klientů. Můžete například ServiceBusClient zaregistrovat další ServiceBusSender dílčí klienty pro publikování zpráv nebo ServiceBusReceiver dílčích klientů pro využívání zpráv.

V souboru Program.cs vyvoláte metodu AddAzureClients rozšíření pro registraci klienta pro každou službu. Následující ukázky kódu poskytují pokyny pro tvůrce aplikací z oborů Microsoft.AspNetCore.Builder názvů a Microsoft.Extensions.Hosting oborů názvů.

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");
    
    // AddAzureClients implicitly creates a DefaultAzureCredential instance
    // Create a credential manually to override the type or access it explicitly for DI registrations
    // This example shows credential reuse for GetQueueNames and AddClient calls downstream
    DefaultAzureCredential credential = new();
    clientBuilder.UseCredential(credential);

    // Register a subclient for each Service Bus Queue
    List<string> queueNames = await GetQueueNames(credential);
    foreach (string queueName in queueNames)
    {
        clientBuilder.AddClient<ServiceBusSender, ServiceBusClientOptions>((_, _, provider) =>
            provider.GetService(typeof(ServiceBusClient)) switch
            {
                ServiceBusClient client => client.CreateSender(queueName),
                _ => throw new InvalidOperationException("Unable to create ServiceBusClient")
            }).WithName(queueName);
    }

    // Register a custom client factory
    clientBuilder.AddClient<AzureOpenAIClient, AzureOpenAIClientOptions>(
        (options, credential, _) => 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;
}

V předchozím kódu:

  • Tajné kódy služby Key Vault, úložiště objektů blob a klienti služby Service Bus se registrují pomocí a AddSecretClientAddBlobServiceClientAddServiceBusClientWithNamespacev uvedeném pořadí. Předají se Uriargumenty - a string-typed. Pokud se chcete vyhnout explicitní specifikaci těchto adres URL, podívejte se na konfiguraci úložiště odděleně od části kódu .
  • Každý registrovaný klient automaticky používá DefaultAzureCredential pro TokenCredential, pokud nenakonfigurujete jiný typ přihlašovacích údajů (například při použití WithCredential).
  • Dílčí klienti služby Service Bus se registrují pro každou frontu ve službě pomocí dílčího klienta a odpovídajících typů možností. Názvy front pro dílčí klienty se načítají pomocí samostatné metody mimo registraci služby, protože GetQueuesAsync metoda musí být spuštěna asynchronně.
  • Klient Azure OpenAI je zaregistrovaný pomocí vlastní továrny klienta prostřednictvím AddClient metody, která poskytuje kontrolu nad tím, jak se instance klienta vytvoří. Vlastní klientské továrny jsou užitečné v následujících případech:
    • Během sestavování klienta je potřeba použít další závislosti.
    • Metoda rozšíření registrace neexistuje pro klienta služby, kterého chcete zaregistrovat.

Použití registrovaných klientů

Když jsou klienti zaregistrovaní, jak je popsáno v části Registrovat klienty a dílčí klienty , můžete je teď používat. V následujícím příkladu se injektáž konstruktoru používá k získání klienta služby Blob Storage a objektu pro podřízené klienty odesílatele služby Service Bus v řadiči rozhraní API ASP.NET Core:

[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();
    }
}

Konfigurace úložiště odděleně od kódu

V části Registrovat klienty a dílčí klienty jste explicitně předali Uriproměnné typu -typed konstruktorům klienta. Tento přístup může způsobit problémy při spouštění kódu v různých prostředích během vývoje a produkce. Tým .NET navrhuje ukládání těchto konfigurací v souborech JSON závislých na prostředí. Můžete mít například nastavení aplikace. Development.json soubor obsahující nastavení vývojového prostředí. Další nastavení aplikace. Production.json soubor by obsahoval nastavení produkčního prostředí atd. Formát souboru je:

{
  "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"
  }
}

Do souboru JSON můžete přidat jakékoli vlastnosti z ClientOptions třídy. Nastavení v konfiguračním souboru JSON lze načíst pomocí IConfiguration.

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

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

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

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

V předchozí ukázce JSON:

Konfigurace více klientů služeb s různými názvy

Představte si, že máte dva účty úložiště: jeden pro soukromé informace a druhý pro veřejné informace. Aplikace po nějaké operaci přenáší data z veřejného do privátního účtu úložiště. Potřebujete dva klienty služby úložiště. K rozlišení těchto dvou klientů použijte metodu WithName rozšíření:

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

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

Například pomocí kontroleru ASP.NET Core se pomocí rozhraní dostanete ke klientovi IAzureClientFactory<TClient> pojmenované služby:

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

Nepojmenovaný klient služby je stále dostupný stejným způsobem jako předtím. Pojmenovaní klienti jsou sčítání.

Konfigurace nové zásady opakování

V určitém okamžiku můžete chtít změnit výchozí nastavení klienta služby. Můžete například chtít různá nastavení opakování nebo použít jinou verzi rozhraní API služby. Nastavení opakování můžete nastavit globálně nebo podle jednotlivých služeb. Předpokládejme, že máte v projektu ASP.NET Core následující soubor appsettings.json :

{
  "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"
  }
}

Zásady opakování můžete změnit tak, aby vyhovovaly vašim potřebám, například:

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

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

Do souboru appsettings.json můžete také umístit přepsání zásad opakování:

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

Viz také

  • Last updated on