Konfigurace připojení bez hesla mezi několika aplikacemi Azure a službami

Článek
02/13/2024

Aplikace často vyžadují zabezpečená připojení mezi několika službami Azure současně. Například podniková instance služby Aplikace Azure Service se může připojit k několika různým účtům úložiště, instanci databáze Azure SQL, sběrnici service bus a dalším.

Spravované identity jsou doporučenou možností ověřování pro zabezpečená připojení bez hesla mezi prostředky Azure. Vývojáři nemusí ručně sledovat a spravovat mnoho různých tajných kódů pro spravované identity, protože většina těchto úloh se zpracovává interně v Azure. V tomto kurzu se dozvíte, jak spravovat připojení mezi více službami pomocí spravovaných identit a klientské knihovny Azure Identity.

Porovnání typů spravovaných identit

Azure poskytuje následující typy spravovaných identit:

Spravované identity přiřazené systémem jsou přímo svázané s jedním prostředkem Azure. Když ve službě povolíte spravovanou identitu přiřazenou systémem, Azure vytvoří propojenou identitu a zpracuje úlohy správy pro tuto identitu interně. Když se prostředek Azure odstraní, identita se odstraní také.
Spravované identity přiřazené uživatelem jsou nezávislé identity vytvořené správcem a dají se přidružit k jednomu nebo více prostředkům Azure. Životní cyklus identity je nezávislý na těchto prostředcích.

Další informace o osvědčených postupech a o tom, kdy používat identity přiřazené systémem a identity přiřazené uživatelem, si můžete přečíst v doporučeních osvědčených postupů pro identity.

Prozkoumání defaultAzureCredential

Spravované identity se obecně implementují v kódu aplikace prostřednictvím třídy volané DefaultAzureCredential z Azure.Identity klientské knihovny. DefaultAzureCredential podporuje více metod ověřování a automaticky určuje, které metody by se měly používat za běhu. Další informace o tomto přístupu najdete v přehledu DefaultAzureCredential.

Připojení aplikace hostované v Azure do několika služeb Azure

Dostali jste za úkol připojit existující aplikaci k více službám a databázím Azure pomocí připojení bez hesla. Aplikace je webové rozhraní API ASP.NET Core hostované ve službě Aplikace Azure Service, i když následující postup platí i pro další hostitelské prostředí Azure, jako jsou Azure Spring Apps, Virtual Machines, Container Apps a AKS.

Tento kurz se vztahuje na následující architektury, i když je možné ho přizpůsobit mnoha dalším scénářům i prostřednictvím minimálních změn konfigurace.

Následující kroky ukazují, jak nakonfigurovat aplikaci tak, aby používala spravovanou identitu přiřazenou systémem a místní vývojový účet pro připojení k více službám Azure.

Vytvoření spravované identity přiřazené systémem

Na webu Azure Portal přejděte k hostované aplikaci, kterou chcete připojit k jiným službám.
Na stránce přehledu služby vyberte Identita.
Přepnutím nastavení Stav na Zapnuto povolíte spravovanou identitu přiřazenou systémem pro službu.

Přiřazení rolí ke spravované identitě pro každou připojenou službu

Přejděte na stránku přehledu účtu úložiště, ke které chcete udělit přístup k identitě.
V navigaci účtu úložiště vyberte Řízení přístupu (IAM ).
Zvolte + Přidat a potom Přidat přiřazení role.
Ve vyhledávacím poli role vyhledejte Přispěvatel dat objektů blob služby Storage, který uděluje oprávnění k provádění operací čtení a zápisu s daty objektů blob. Můžete přiřadit libovolnou roli, která je vhodná pro váš případ použití. V seznamu vyberte Přispěvatel dat objektů blob úložiště a zvolte Další.
Na obrazovce Přidat přiřazení role jako možnost Přiřadit přístup vyberte Spravovaná identita. Pak zvolte +Vybrat členy.
V informačním rámečku vyhledejte spravovanou identitu, kterou jste vytvořili, zadáním názvu vaší služby App Service. Vyberte identitu přiřazenou systémem a pak výběrem možnosti Vybrat zavřete kontextovou nabídku.
Vyberte Další několikrát, dokud nebudete moct vybrat Zkontrolovat a přiřadit, abyste dokončili přiřazení role.
Tento postup opakujte pro ostatní služby, ke kterému se chcete připojit.

Aspekty místního vývoje

Přístup k prostředkům Azure pro místní vývoj můžete také povolit přiřazením rolí k uživatelskému účtu stejným způsobem, jakým jste přiřadili role spravované identitě.

Po přiřazení role Přispěvatel dat v objektu blob služby Storage spravované identitě v části Přiřadit přístup vyberte tentokrát uživatele, skupinu nebo instanční objekt. Pokud chcete znovu otevřít rozevírací nabídku, zvolte + Vybrat členy .
Vyhledejte účet user@domain nebo skupinu zabezpečení Microsoft Entra, ke které chcete udělit přístup podle e-mailové adresy nebo jména, a pak ji vyberte. Mělo by to být stejný účet, pomocí který se přihlašujete k místním nástrojům pro vývoj, jako je Visual Studio nebo Azure CLI.

Poznámka:

Tyto role můžete přiřadit také skupině zabezpečení Microsoft Entra, pokud pracujete na týmu s více vývojáři. Pak můžete do této skupiny umístit libovolného vývojáře, který potřebuje přístup k místnímu vývoji aplikace.

Implementace kódu aplikace

Uvnitř projektu přidejte odkaz na Azure.Identity balíček NuGet. Tato knihovna obsahuje všechny nezbytné entity k implementaci DefaultAzureCredential. Můžete také přidat jakékoli další knihovny Azure, které jsou pro vaši aplikaci relevantní. V tomto příkladu Azure.Storage.Blobs Azure.KeyVault.Keys se balíčky a balíčky přidají, aby se připojily ke službě Blob Storage a key Vaultu.

dotnet add package Azure.Identity
dotnet add package Azure.Storage.Blobs
dotnet add package Azure.KeyVault.Keys

Na začátek Program.cs souboru přidejte následující příkazy using:

using Azure.Identity;
using Azure.Storage.Blobs;
using Azure.Security.KeyVault.Keys;

Program.cs V souboru kódu projektu vytvořte instance nezbytných služeb, ke které se vaše aplikace připojí. Následující příklady se připojují ke službě Blob Storage a service bus pomocí odpovídajících tříd sady SDK.

var blobServiceClient = new BlobServiceClient(
    new Uri("https://<your-storage-account>.blob.core.windows.net"),
    new DefaultAzureCredential(credOptions));

var serviceBusClient = new ServiceBusClient("<your-namespace>", new DefaultAzureCredential());
var sender = serviceBusClient.CreateSender("producttracking");

V projektu přidejte azure-identity závislost do souboru pom.xml . Tato knihovna obsahuje všechny potřebné entity k implementaci DefaultAzureCredential. Můžete také přidat jakékoli další závislosti Azure, které jsou pro vaši aplikaci relevantní. V tomto příkladu azure-storage-blob azure-messaging-servicebus se přidají závislosti pro připojení ke službě Blob Storage a key Vaultu.

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.azure</groupId>
      <artifactId>azure-sdk-bom</artifactId>
      <version>1.2.5</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
<dependencies>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
  </dependency>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-storage-blob</artifactId>
  </dependency>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-messaging-servicebus</artifactId>
  </dependency>
</dependencies>

V kódu projektu vytvořte instance nezbytných služeb, ke které se vaše aplikace připojí. Následující příklady se připojují ke službě Blob Storage a service bus pomocí odpovídajících tříd sady SDK.

class Demo {

    public static void main(String[] args) {

        DefaultAzureCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().build();

        BlobServiceClient blobServiceClient = new BlobServiceClientBuilder()
            .endpoint("https://<your-storage-account>.blob.core.windows.net")
            .credential(defaultAzureCredential)
            .buildClient();

        ServiceBusClientBuilder clientBuilder = new ServiceBusClientBuilder().credential(defaultAzureCredential);
        ServiceBusSenderClient serviceBusSenderClient = clientBuilder.sender()
                                                                     .queueName("producttracking")
                                                                     .buildClient();
    }

}

Uvnitř projektu stačí přidat jenom závislosti služeb, které používáte. V tomto příkladu spring-cloud-azure-starter-storage-blob spring-cloud-azure-starter-servicebus se přidají závislosti pro připojení ke službě Blob Storage a key Vaultu.

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.azure.spring</groupId>
      <artifactId>spring-cloud-azure-dependencies</artifactId>
      <version>4.5.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
<dependencies>
  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-storage-blob</artifactId>
  </dependency>
  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-servicebus</artifactId>
  </dependency>
</dependencies>

spring:
  cloud:
    azure:
      servicebus:
        namespace: <service-bus-name>
        entity-name: <service-bus-entity-name>
        entity-type: <service-bus-entity-type>
      storage:
        blob:
          account-name: <storage-account-name>

@Service
public class ExampleService {

    @Autowired
    private BlobServiceClient blobServiceClient;

    @Autowired
    private ServiceBusSenderClient serviceBusSenderClient;

}

Uvnitř projektu přidejte odkaz na @azure/identity balíček pomocí npm. Tato knihovna obsahuje všechny nezbytné entity k implementaci DefaultAzureCredential. Nainstalujte všechny ostatní knihovny sady Azure SDK, které jsou pro vaši aplikaci relevantní.
```
npm install --save @azure/identity @azure/storage-blob @azure/keyvault-keys
```
V horní části index.js souboru přidejte následující import příkazy pro import potřebných klientských tříd pro služby, ke které se vaše aplikace připojí:
```
import { DefaultAzureCredential } from "@azure/identity";
import { BlobServiceClient } from "@azure/storage-blob";
import { KeyClient } from "@azure/keyvault-keys";
```

index.js V souboru vytvořte klientské objekty pro služby Azure, ke kterému se vaše aplikace připojí. Následující příklady se připojují ke službě Blob Storage a key Vaultu pomocí odpovídajících tříd sady SDK.

// Azure resource names
const storageAccount = process.env.AZURE_STORAGE_ACCOUNT_NAME;
const keyVaultName = process.env.AZURE_KEYVAULT_NAME;

// Create client for Blob Storage using managed identity
const blobServiceClient = new BlobServiceClient(
  `https://${storageAccount}.blob.core.windows.net`,
  new DefaultAzureCredential()
);

// Create client for Key Vault using managed identity
const keyClient = new KeyClient(`https://${keyVaultName}.vault.azure.net`, new DefaultAzureCredential());

// Create a new key in Key Vault
const result = await keyClient.createKey(keyVaultName, "RSA");

Když se tento kód aplikace spustí místně, DefaultAzureCredential vyhledá řetězec přihlašovacích údajů s prvními dostupnými přihlašovacími údaji. Pokud je hodnota Managed_Identity_Client_ID null místně, automaticky použije přihlašovací údaje z místního Azure CLI nebo přihlášení k sadě Visual Studio. Další informace o tomto procesu najdete v přehledu knihovny identit Azure.

Když je aplikace nasazená do Azure, DefaultAzureCredential automaticky načte proměnnou Managed_Identity_Client_ID ze služby App Service Environment. Tato hodnota bude dostupná, když je spravovaná identita přidružená k vaší aplikaci.

Tento celkový proces zajišťuje, že vaše aplikace může bezpečně běžet místně a v Azure bez nutnosti jakýchkoli změn kódu.

Připojení více aplikací s využitím více spravovaných identit

I když aplikace v předchozím příkladu všechny sdílely stejné požadavky na přístup ke službě, skutečná prostředí jsou často více nuancí. Představte si scénář, kdy se ke stejnému účtu úložiště připojuje více aplikací, ale dvě z těchto aplikací také přistupují k různým službám nebo databázím.

Pokud chcete nakonfigurovat toto nastavení v kódu, ujistěte se, že vaše aplikace zaregistruje samostatné služby pro připojení ke každému účtu úložiště nebo databázi. Při konfiguraci DefaultAzureCredentialnezapomeňte načíst správná ID klienta spravované identity pro každou službu. Následující příklad kódu konfiguruje následující připojení služeb:

Dvě připojení k samostatným účtům úložiště pomocí sdílené spravované identity přiřazené uživatelem
Připojení ke službám Azure Cosmos DB a Azure SQL s využitím druhé sdílené spravované identity přiřazené uživatelem

// Get the first user-assigned managed identity ID to connect to shared storage
const clientIdStorage = Environment.GetEnvironmentVariable("Managed_Identity_Client_ID_Storage");

// First blob storage client that using a managed identity
BlobServiceClient blobServiceClient = new BlobServiceClient(
    new Uri("https://<receipt-storage-account>.blob.core.windows.net"),
    new DefaultAzureCredential()
    {
        ManagedIdentityClientId = clientIDstorage
    });

// Second blob storage client that using a managed identity
BlobServiceClient blobServiceClient2 = new BlobServiceClient(
    new Uri("https://<contract-storage-account>.blob.core.windows.net"),
    new DefaultAzureCredential()
    {
        ManagedIdentityClientId = clientIDstorage
    });


// Get the second user-assigned managed identity ID to connect to shared databases
var clientIDdatabases = Environment.GetEnvironmentVariable("Managed_Identity_Client_ID_Databases");

// Create an Azure Cosmos DB client
CosmosClient client = new CosmosClient(
    accountEndpoint: Environment.GetEnvironmentVariable("COSMOS_ENDPOINT", EnvironmentVariableTarget.Process),
    new DefaultAzureCredential()
    {
        ManagedIdentityClientId = clientIDdatabases
    });

// Open a connection to Azure SQL using a managed identity
string ConnectionString1 = @"Server=<azure-sql-hostname>.database.windows.net; User Id=ClientIDOfTheManagedIdentity; Authentication=Active Directory Default; Database=<database-name>";

using (SqlConnection conn = new SqlConnection(ConnectionString1))
{
    conn.Open();
}

Do souboru pom.xml přidejte následující:

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.azure</groupId>
      <artifactId>azure-sdk-bom</artifactId>
      <version>1.2.5</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
<dependencies>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
  </dependency>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-storage-blob</artifactId>
  </dependency>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-cosmos</artifactId>
  </dependency>
  <dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
    <version>11.2.1.jre17</version>
  </dependency>
</dependencies>

Do kódu přidejte následující kód:

class Demo {

    public static void main(String[] args) {
        // Get the first user-assigned managed identity ID to connect to shared storage
        String clientIdStorage = System.getenv("Managed_Identity_Client_ID_Storage");

        // Get the DefaultAzureCredential from clientIdStorage
        DefaultAzureCredential storageCredential =
            new DefaultAzureCredentialBuilder().managedIdentityClientId(clientIdStorage).build();

        // First blob storage client that using a managed identity
        BlobServiceClient blobServiceClient = new BlobServiceClientBuilder()
            .endpoint("https://<receipt-storage-account>.blob.core.windows.net")
            .credential(storageCredential)
            .buildClient();

        // Second blob storage client that using a managed identity
        BlobServiceClient blobServiceClient2 = new BlobServiceClientBuilder()
            .endpoint("https://<contract-storage-account>.blob.core.windows.net")
            .credential(storageCredential)
            .buildClient();

        // Get the second user-assigned managed identity ID to connect to shared databases
        String clientIdDatabase = System.getenv("Managed_Identity_Client_ID_Databases");

        // Create an Azure Cosmos DB client
        CosmosClient cosmosClient = new CosmosClientBuilder()
            .endpoint("https://<cosmos-db-account>.documents.azure.com:443/")
            .credential(new DefaultAzureCredentialBuilder().managedIdentityClientId(clientIdDatabase).build())
            .buildClient();

        // Open a connection to Azure SQL using a managed identity
        String connectionUrl = "jdbc:sqlserver://<azure-sql-hostname>.database.windows.net:1433;"
            + "database=<database-name>;encrypt=true;trustServerCertificate=false;hostNameInCertificate=*.database"
            + ".windows.net;loginTimeout=30;Authentication=ActiveDirectoryMSI;";
        try {
            Connection connection = DriverManager.getConnection(connectionUrl);
            Statement statement = connection.createStatement();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Do souboru pom.xml přidejte následující:

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.azure.spring</groupId>
      <artifactId>spring-cloud-azure-dependencies</artifactId>
      <version>4.5.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
<dependencies>
  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-storage-blob</artifactId>
  </dependency>
  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-cosmos</artifactId>
  </dependency>
  <dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
  </dependency>
</dependencies>

Do souboru application.yml přidejte následující:

spring:
  cloud:
    azure:
      cosmos:
        endpoint: https://<cosmos-db-account>.documents.azure.com:443/
        credential:
          client-id: <Managed_Identity_Client_ID_Databases>
          managed-identity-enabled: true
      storage:
        blob:
          endpoint: https://<contract-storage-account>.blob.core.windows.net
          credential:
            client-id: <Managed_Identity_Client_ID_Storage>
            managed-identity-enabled: true
  datasource:
    url: jdbc:sqlserver://<azure-sql-hostname>.database.windows.net:1433;database=<database-name>;encrypt=true;trustServerCertificate=false;hostNameInCertificate=*.database.windows.net;loginTimeout=30;Authentication=ActiveDirectoryMSI;

Do kódu přidejte následující kód:

Poznámka:

Spring Cloud Azure nepodporuje konfiguraci více klientů stejné služby, následující kódy pro tuto situaci vytvářejí více fazolí.

@Configuration
public class AzureStorageConfiguration {

    @Bean("secondBlobServiceClient")
    public BlobServiceClient secondBlobServiceClient(BlobServiceClientBuilder builder) {
        return builder.endpoint("https://<receipt-storage-account>.blob.core.windows.net").buildClient();
    }

    @Bean("firstBlobServiceClient")
    public BlobServiceClient firstBlobServiceClient(BlobServiceClientBuilder builder) {
        return builder.buildClient();
    }
}

@Service
public class ExampleService {

    @Autowired
    @Qualifier("firstBlobServiceClient")
    private BlobServiceClient blobServiceClient;

    @Autowired
    @Qualifier("secondBlobServiceClient")
    private BlobServiceClient blobServiceClient2;

    @Autowired
    private CosmosClient cosmosClient;

    @Autowired
    private JdbcTemplate jdbcTemplate;

}

Uvnitř projektu přidejte odkaz na @azure/identity balíček pomocí npm. Tato knihovna obsahuje všechny nezbytné entity k implementaci DefaultAzureCredential. Nainstalujte všechny ostatní knihovny sady Azure SDK, které jsou pro vaši aplikaci relevantní.
```
npm install --save @azure/identity @azure/storage-blob @azure/cosmos mssql
```
V horní části index.js souboru přidejte následující import příkazy pro import potřebných klientských tříd pro služby, ke které se vaše aplikace připojí:
```
import { DefaultAzureCredential } from "@azure/identity";
import { BlobServiceClient } from "@azure/storage-blob";
import { KeyClient } from "@azure/keyvault-keys";
```

index.js V souboru vytvořte klientské objekty pro služby Azure, ke kterému se vaše aplikace připojí. Následující příklady se připojují ke službě Blob Storage, Cosmos DB a Azure SQL pomocí odpovídajících tříd sady SDK.

// Get the first user-assigned managed identity ID to connect to shared storage
const clientIdStorage = process.env.MANAGED_IDENTITY_CLIENT_ID_STORAGE;

// Storage account names
const storageAccountName1 = process.env.AZURE_STORAGE_ACCOUNT_NAME_1;
const storageAccountName2 = process.env.AZURE_STORAGE_ACCOUNT_NAME_2;

// First blob storage client that using a managed identity
const blobServiceClient = new BlobServiceClient(
  `https://${storageAccountName1}.blob.core.windows.net`,
  new DefaultAzureCredential({
    managedIdentityClientId: clientIdStorage
  })
);

// Second blob storage client that using a managed identity
const blobServiceClient2 = new BlobServiceClient(
  `https://${storageAccountName2}.blob.core.windows.net`,
  new DefaultAzureCredential({
    managedIdentityClientId: clientIdStorage
  })
);

// Get the second user-assigned managed identity ID to connect to shared databases
const clientIdDatabases = process.env.MANAGED_IDENTITY_CLIENT_ID_DATABASES;

// Cosmos DB Account endpoint
const cosmosDbAccountEndpoint = process.env.COSMOS_ENDPOINT;

// Create an Azure Cosmos DB client
const client = new CosmosClient({
  endpoint: cosmosDbAccountEndpoint,
  credential: new DefaultAzureCredential({
    managedIdentityClientId: clientIdDatabases
  })
});

// Open a connection to Azure SQL using a managed identity with mssql package
// mssql reads the environment variables to get the managed identity
const server = process.env.AZURE_SQL_SERVER;
const database = process.env.AZURE_SQL_DATABASE;
const port = parseInt(process.env.AZURE_SQL_PORT);
const type = process.env.AZURE_SQL_AUTHENTICATIONTYPE;

const config = {
    server,
    port,
    database,
    authentication: {
        type                // <---- Passwordless connection
    },
    options: {
        encrypt: true
    }
};

await sql.connect(sqlConfig);

Spravovanou identitu přiřazenou uživatelem a spravovanou identitu přiřazenou systémem můžete také přidružit k prostředku současně. To může být užitečné ve scénářích, kdy všechny aplikace vyžadují přístup ke stejným sdíleným službám, ale jedna z aplikací má také velmi specifickou závislost na další službě. Použití identity přiřazené systémem také zajišťuje, aby se identita svázaná s danou konkrétní aplikací po odstranění odstranila, což může pomoct udržet vaše prostředí čisté.

Tyto typyscénářůch

Další kroky

V tomto kurzu jste zjistili, jak migrovat aplikaci na připojení bez hesla. Podrobnější informace o konceptech probíraných v tomto článku najdete v následujících zdrojích informací:

Autorizace přístupu k objektům blob pomocí Microsoft Entra ID
Další informace o .NET Core najdete v tématu Začínáme s .NET během 10 minut.

Sdílet prostřednictvím