Konfigurera lösenordslösa anslutningar mellan flera Azure-appar och -tjänster

Artikel
02/13/2024

Program kräver ofta säkra anslutningar mellan flera Azure-tjänster samtidigt. Till exempel kan en Azure App Service-företagsinstans ansluta till flera olika lagringskonton, en Azure SQL-databasinstans, en Service Bus med mera.

Hanterade identiteter är det rekommenderade autentiseringsalternativet för säkra, lösenordslösa anslutningar mellan Azure-resurser. Utvecklare behöver inte spåra och hantera många olika hemligheter för hanterade identiteter manuellt, eftersom de flesta av dessa uppgifter hanteras internt av Azure. I den här självstudien beskrivs hur du hanterar anslutningar mellan flera tjänster med hanterade identiteter och Azure Identity-klientbiblioteket.

Jämför typerna av hanterade identiteter

Azure tillhandahåller följande typer av hanterade identiteter:

Systemtilldelade hanterade identiteter är direkt kopplade till en enda Azure-resurs. När du aktiverar en systemtilldelad hanterad identitet på en tjänst skapar Azure en länkad identitet och hanterar administrativa uppgifter för den identiteten internt. När Azure-resursen tas bort tas även identiteten bort.
Användartilldelade hanterade identiteter är oberoende identiteter som skapas av en administratör och kan associeras med en eller flera Azure-resurser. Identitetens livscykel är oberoende av dessa resurser.

Du kan läsa mer om metodtips och när du ska använda systemtilldelade identiteter jämfört med användartilldelade identiteter i rekommendationerna om bästa praxis för identiteter.

Utforska StandardAzureCredential

Hanterade identiteter implementeras vanligtvis i programkoden via en klass som anropas DefaultAzureCredential från Azure.Identity klientbiblioteket. DefaultAzureCredential stöder flera autentiseringsmetoder och avgör automatiskt vilka som ska användas vid körning. Du kan läsa mer om den här metoden i Översikt över DefaultAzureCredential.

Anslut en Azure-värdbaserad app till flera Azure-tjänster

Du har fått i uppgift att ansluta en befintlig app till flera Azure-tjänster och databaser med lösenordslösa anslutningar. Programmet är ett ASP.NET Core-webb-API som finns i Azure App Service, men stegen nedan gäller även för andra Azure-värdmiljöer, till exempel Azure Spring Apps, Virtual Machines, Container Apps och AKS.

Den här självstudien gäller för följande arkitekturer, även om den kan anpassas till många andra scenarier samt genom minimala konfigurationsändringar.

Följande steg visar hur du konfigurerar en app för att använda en systemtilldelad hanterad identitet och ditt lokala utvecklingskonto för att ansluta till flera Azure-tjänster.

Skapa en systemtilldelad hanterad identitet

I Azure-portalen navigerar du till det värdbaserade program som du vill ansluta till andra tjänster.
På sidan Tjänstöversikt väljer du Identitet.
Växla statusinställningen till På för att aktivera en systemtilldelad hanterad identitet för tjänsten.

Tilldela roller till den hanterade identiteten för varje ansluten tjänst

Gå till översiktssidan för det lagringskonto som du vill ge åtkomst till din identitet.
Välj Åtkomstkontroll (IAM) i navigeringen för lagringskontot.
Välj + Lägg till och sedan Lägg till rolltilldelning.
I sökrutan Roll söker du efter Storage Blob Data Contributor, som ger behörighet att utföra läs- och skrivåtgärder på blobdata. Du kan tilldela vilken roll som är lämplig för ditt användningsfall. Välj Storage Blob Data-deltagare i listan och välj Nästa.
På skärmen Lägg till rolltilldelning går du till alternativet Tilldela åtkomst till och väljer Hanterad identitet. Välj sedan +Välj medlemmar.
I den utfällbara menyn söker du efter den hanterade identitet som du skapade genom att ange namnet på din apptjänst. Välj den systemtilldelade identiteten och välj sedan Välj för att stänga den utfällbara menyn.
Välj Nästa ett par gånger tills du kan välja Granska + tilldela för att slutföra rolltilldelningen.
Upprepa den här processen för de andra tjänster som du vill ansluta till.

Överväganden för lokal utveckling

Du kan också aktivera åtkomst till Azure-resurser för lokal utveckling genom att tilldela roller till ett användarkonto på samma sätt som du tilldelade roller till din hanterade identitet.

När du har tilldelat rollen Storage Blob Data Contributor till din hanterade identitet, under Tilldela åtkomst till, väljer du användaren, gruppen eller tjänstens huvudnamn den här gången. Välj + Välj medlemmar för att öppna den utfällbara menyn igen.
Sök efter det user@domain-konto eller Microsoft Entra-säkerhetsgrupp som du vill bevilja åtkomst till via e-postadress eller namn och välj sedan det. Detta bör vara samma konto som du använder för att logga in på dina lokala utvecklingsverktyg med, till exempel Visual Studio eller Azure CLI.

Kommentar

Du kan också tilldela dessa roller till en Microsoft Entra-säkerhetsgrupp om du arbetar i ett team med flera utvecklare. Du kan sedan placera alla utvecklare i gruppen som behöver åtkomst för att utveckla appen lokalt.

Implementera programkoden

I projektet lägger du till en referens till Azure.Identity NuGet-paketet. Det här biblioteket innehåller alla nödvändiga entiteter för att implementera DefaultAzureCredential. Du kan också lägga till andra Azure-bibliotek som är relevanta för din app. I det här exemplet läggs paketen Azure.Storage.Blobs och Azure.KeyVault.Keys till för att ansluta till Blob Storage och Key Vault.

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

Överst Program.cs i filen lägger du till följande using-instruktioner:

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

I filen i Program.cs projektkoden skapar du instanser av de nödvändiga tjänster som appen ansluter till. Följande exempel ansluter till Blob Storage och Service Bus med motsvarande SDK-klasser.

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

Lägg till beroendet i azure-identity pom.xml-filen i projektet. Det här biblioteket innehåller alla nödvändiga entiteter för att implementera DefaultAzureCredential. Du kan också lägga till andra Azure-beroenden som är relevanta för din app. I det här exemplet läggs beroendena azure-storage-blob och azure-messaging-servicebus till för att ansluta till Blob Storage och Key Vault.

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

I projektkoden skapar du instanser av de nödvändiga tjänster som appen ansluter till. Följande exempel ansluter till Blob Storage och Service Bus med motsvarande SDK-klasser.

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

}

I projektet behöver du bara lägga till tjänstberoenden som du använder. I det här exemplet läggs beroendena spring-cloud-azure-starter-storage-blob och spring-cloud-azure-starter-servicebus till för att ansluta till Blob Storage och Key Vault.

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

I projektkoden skapar du instanser av de nödvändiga tjänster som appen ansluter till. Följande exempel ansluter till Blob Storage och Service Bus med motsvarande SDK-klasser.

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;

}

I projektet använder du npm för att lägga till en referens till @azure/identity paketet. Det här biblioteket innehåller alla nödvändiga entiteter för att implementera DefaultAzureCredential. Installera andra Azure SDK-bibliotek som är relevanta för din app.
```
npm install --save @azure/identity @azure/storage-blob @azure/keyvault-keys
```

Överst index.js i filen lägger du till följande import instruktioner för att importera de nödvändiga klientklasserna för de tjänster som appen ansluter till:

import { DefaultAzureCredential } from "@azure/identity";
import { BlobServiceClient } from "@azure/storage-blob";
import { KeyClient } from "@azure/keyvault-keys";

index.js Skapa klientobjekt för de Azure-tjänster som appen ansluter till i filen. Följande exempel ansluter till Blob Storage och Key Vault med motsvarande SDK-klasser.

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

När den här programkoden körs lokalt DefaultAzureCredential söker du i en autentiseringskedja efter de första tillgängliga autentiseringsuppgifterna. Om är Managed_Identity_Client_ID null lokalt använder den automatiskt autentiseringsuppgifterna från din lokala Azure CLI- eller Visual Studio-inloggning. Du kan läsa mer om den här processen i översikten över Azure Identity Library.

När programmet distribueras till Azure DefaultAzureCredential hämtar variabeln Managed_Identity_Client_ID automatiskt från App Service-miljön. Det värdet blir tillgängligt när en hanterad identitet är associerad med din app.

Den här övergripande processen säkerställer att din app kan köras på ett säkert sätt lokalt och i Azure utan att det behövs några kodändringar.

Anslut flera appar med flera hanterade identiteter

Även om apparna i föregående exempel alla har samma åtkomstkrav för tjänsten, är verkliga miljöer ofta mer nyanserade. Tänk dig ett scenario där flera appar alla ansluter till samma lagringskonton, men två av apparna också har åtkomst till olika tjänster eller databaser.

Om du vill konfigurera den här konfigurationen i koden kontrollerar du att programmet registrerar separata tjänster för att ansluta till varje lagringskonto eller databas. Se till att hämta rätt hanterade identitetsklient-ID:er för varje tjänst när du konfigurerar DefaultAzureCredential. Följande kodexempel konfigurerar följande tjänstanslutningar:

Två anslutningar till separata lagringskonton med en delad användartilldelad hanterad identitet
En anslutning till Azure Cosmos DB- och Azure SQL-tjänster med en andra delad användartilldelad hanterad identitet

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

Lägg till följande i din pom.xml-fil :

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

Lägg till följande i koden:

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

Lägg till följande i din pom.xml-fil :

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

Lägg till följande i din application.yml-fil :

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;

Lägg till följande i koden:

Kommentar

Spring Cloud Azure har inte stöd för att konfigurera flera klienter för samma tjänst. Följande koder skapar flera bönor för den här situationen.

@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;

}

I projektet använder du npm för att lägga till en referens till @azure/identity paketet. Det här biblioteket innehåller alla nödvändiga entiteter för att implementera DefaultAzureCredential. Installera andra Azure SDK-bibliotek som är relevanta för din app.
```
npm install --save @azure/identity @azure/storage-blob @azure/cosmos mssql
```

Överst index.js i filen lägger du till följande import instruktioner för att importera de nödvändiga klientklasserna för de tjänster som appen ansluter till:

import { DefaultAzureCredential } from "@azure/identity";
import { BlobServiceClient } from "@azure/storage-blob";
import { KeyClient } from "@azure/keyvault-keys";

index.js Skapa klientobjekt för de Azure-tjänster som appen ansluter till i filen. Följande exempel ansluter till Blob Storage, Cosmos DB och Azure SQL med motsvarande SDK-klasser.

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

Du kan också associera en användartilldelad hanterad identitet samt en systemtilldelad hanterad identitet till en resurs samtidigt. Detta kan vara användbart i scenarier där alla appar kräver åtkomst till samma delade tjänster, men en av apparna har också ett mycket specifikt beroende av en ytterligare tjänst. Genom att använda en systemtilldelad identitet ser du också till att identiteten som är kopplad till den specifika appen tas bort när appen tas bort, vilket kan hjälpa dig att hålla miljön ren.

Dessa typer av scenarier utforskas mer ingående i rekommendationerna om bästa praxis för identiteter.

Nästa steg

I den här självstudien har du lärt dig hur du migrerar ett program till lösenordslösa anslutningar. Du kan läsa följande resurser för att utforska begreppen som beskrivs i den här artikeln mer ingående:

Auktorisera åtkomst till blobar med hjälp av Microsoft Entra-ID
Mer information om .NET Core finns i Kom igång med .NET på 10 minuter.

Dela via