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íčku s předponou:Azure.

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 používá pro demonstrační účely tajné kódy služby Key Vault, úložiště objektů blob a knihovny Service Bus. 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

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ů.

WebApplicationBuilder

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

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

List<string> queueNames = await GetQueueNames();

builder.Services.AddAzureClients(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");
    clientBuilder.UseCredential(new DefaultAzureCredential());

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

WebApplication app = builder.Build();

async Task<List<string>> GetQueueNames()
{
    // Query the available queues for the Service Bus namespace.
    var adminClient = new ServiceBusAdministrationClient
        ("<your_namespace>.servicebus.windows.net", new DefaultAzureCredential());
    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;
}

HostApplicationBuilder

using Azure.Identity;
using Azure.Messaging.ServiceBus;
using Azure.Messaging.ServiceBus.Administration;
using Microsoft.Extensions.Azure;
using Microsoft.Extensions.Hosting;

List<string> queueNames = await GetQueueNames();

IHost host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.AddAzureClients(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");
            clientBuilder.UseCredential(new DefaultAzureCredential());

            // Register subclients for Service Bus
            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);
            }
        });
    }).Build();

await host.RunAsync();

async Task<List<string>> GetQueueNames()
{
    // Query the available queues for the Service Bus namespace.
    var adminClient = new ServiceBusAdministrationClient
        ("<your_namespace>.servicebus.windows.net", new DefaultAzureCredential());
    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;
}

HostBuilder

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

List<string> queueNames = await GetQueueNames();

IHost host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.AddAzureClients(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");
            clientBuilder.UseCredential(new DefaultAzureCredential());

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

await host.RunAsync();

async Task<List<string>> GetQueueNames()
{
    // Query the available queues for the Service Bus namespace.
    var adminClient = new ServiceBusAdministrationClient
        ("<your_namespace>.servicebus.windows.net", new DefaultAzureCredential());
    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 .
• DefaultAzureCredential slouží k splnění požadavku argumentu pro každého registrovaného TokenCredential klienta. Když se vytvoří jeden z klientů, DefaultAzureCredential použije se k ověření.
• 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ě.

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 v řadiči rozhraní API ASP.NET Core:

[ApiController]
[Route("[controller]")]
public class MyApiController : ControllerBase
{
    private readonly BlobServiceClient _blobServiceClient;
  
    public MyApiController(BlobServiceClient blobServiceClient)
    {
        _blobServiceClient = blobServiceClient;
    }
  
    [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.

WebApplicationBuilder

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

HostApplicationBuilder

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

HostBuilder

IHost host = Host.CreateDefaultBuilder(args)
    .ConfigureServices((hostContext, services) =>
    {
        services.AddHostedService<Worker>();
        services.AddAzureClients(clientBuilder =>
        {
            clientBuilder.AddSecretClient(
                hostContext.Configuration.GetSection("KeyVault"));

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

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

            clientBuilder.UseCredential(new DefaultAzureCredential());

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

V předchozí ukázce JSON:

• Názvy klíčů nejvyšší úrovně, , AzureDefaultsKeyVault, ServiceBusa Storage, jsou libovolné. Všechny ostatní názvy klíčů mají významnost a serializace JSON se provádí bez rozlišování malých a malých písmen.
• Literál objektu AzureDefaults.Retry :
  • Představuje nastavení konfigurace zásad opakování.
  • Retry Odpovídá vlastnosti. V literálu objektu MaxRetries najdete klíč, který odpovídá MaxRetries vlastnosti.
• Hodnoty KeyVault:VaultUri, ServiceBus:Namespacea Storage:ServiceUri klíč mapují na Uri- a string-typed argumenty Azure.Security.KeyVault.Secrets.SecretClient.SecretClient(Uri, TokenCredential, SecretClientOptions), Azure.Messaging.ServiceBus.ServiceBusClient.ServiceBusClient(String)a Azure.Storage.Blobs.BlobServiceClient.BlobServiceClient(Uri, TokenCredential, BlobClientOptions) konstruktor přetížení, v uvedeném pořadí. Varianty TokenCredential konstruktorů se používají, protože výchozí TokenCredential nastavení je nastaveno prostřednictvím Microsoft.Extensions.Azure.AzureClientFactoryBuilder.UseCredential(TokenCredential) volání metody.

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

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é

• Injektáž závislostí v ASP.NET Core
• Konfigurace v .NET
• Konfigurace v ASP.NET Core