Intégrer Azure Cache pour Redis avec le connecteur de services

Vous pouvez connecter Azure Cache pour Redis à d’autres services cloud à l’aide du connecteur de services. Cet article décrit les méthodes d’authentification et les clients pris en charge, puis fournit un exemple de code. Il révèle également les noms et les valeurs des variables d’environnement par défaut (ou configuration Spring Boot) que vous obtenez lorsque vous créez la connexion de services.

Service de calcul pris en charge

Vous pouvez utiliser le connecteur de services pour connecter les services de calcul suivants à Azure Cache pour Redis :

• Azure App Service
• Azure Container Apps
• Azure Functions
• Azure Kubernetes Service (AKS)
• Azure Spring Apps

Types d’authentification et de client pris en charge

Le tableau suivant montre quelles combinaisons de méthodes d’authentification et de clients sont prises en charge pour connecter votre service de calcul à Azure Cache pour Redis à l’aide du connecteur de services. « Oui » signifie que la combinaison est prise en charge. « Non » signifie qu’elle n’est pas prise en charge.

Type de client	Identité managée affectée par le système	Identité managée affectée par l’utilisateur	Secret / chaîne de connexion	Principal du service
.NET	Oui	Oui	Oui	Oui
Go	Non	Non	Oui	Non
Java	Oui	Oui	Oui	Oui
Java - Spring Boot	Non	Non	Oui	Non
Node.JS	Oui	Oui	Oui	Oui
Python	Oui	Oui	Oui	Oui
Aucun	Oui	Oui	Oui	Oui

Tous les types de client, à l’exception de Go et Java - Spring Boot, peuvent utiliser l’une des méthodes d’authentification référencées dans le tableau pour se connecter à Azure Cache pour Redis à l’aide du connecteur de services. Les seules méthodes d’authentification prises en charge pour Go et Java - Spring Boot sont secret/chaîne de connexion ou principal de service.

Noms des variables d’environnement par défaut ou propriétés de l’application et exemple de code

Utilisez les noms des variables d’environnement et les propriétés d’application suivants pour connecter des services de calcul à votre serveur Redis. Pour en savoir plus sur les conventions d’affectation de noms, consultez l’article Services internes du connecteur de services.

Identité managée affectée par le système

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_REDIS_HOST	Point de terminaison Redis	<RedisName>.redis.cache.windows.net

Exemple de code

Les étapes et le code suivants vous montrent comment utiliser une identité managée affectée par le système pour se connecter à Redis.

.NET

1. Installez des dépendances.

   dotnet add package Microsoft.Azure.StackExchangeRedis --version 3.2.0
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’information, consultez Extension Microsoft.Azure.StackExchangeRedis.

   using StackExchange.Redis;
   var cacheHostName = Environment.GetEnvironmentVariable("AZURE_REDIS_HOST");
   var configurationOptions = ConfigurationOptions.Parse($"{cacheHostName}:6380");
   
   // Uncomment the following lines corresponding to the authentication type you want to use.
   // For system-assigned identity.
   // await configurationOptions.ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential());
   
   // For user-assigned identity.
   // var managedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_REDIS_CLIENTID");
   // await configurationOptions.ConfigureForAzureWithUserAssignedManagedIdentityAsync(managedIdentityClientId);
   
   // Service principal secret.
   // var clientId = Environment.GetEnvironmentVariable("AZURE_REDIS_CLIENTID");
   // var tenantId = Environment.GetEnvironmentVariable("AZURE_REDIS_TENANTID");
   // var secret = Environment.GetEnvironmentVariable("AZURE_REDIS_CLIENTSECRET");
   // await configurationOptions.ConfigureForAzureWithServicePrincipalAsync(clientId, tenantId, secret);
   
   
   var connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(configurationOptions);
   

Java

1. Ajoutez la dépendance suivante dans votre fichier pom.xml :

   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
       <version>1.11.2</version> <!-- {x-version-update;com.azure:azure-identity;dependency} -->
   </dependency>
   
   <dependency>
       <groupId>redis.clients</groupId>
       <artifactId>jedis</artifactId>
       <version>5.1.0</version>  <!-- {x-version-update;redis.clients:jedis;external_dependency} -->
   </dependency>
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’informations, consultez Authentification-Azure-AAD-avec-Jedis.

   import redis.clients.jedis.DefaultJedisClientConfig;
   import redis.clients.jedis.Jedis;
   import redis.clients.jedis.JedisShardInfo;
   import java.net.URI;
   
   // Uncomment the following lines corresponding to the authentication type you want to use.
   // For system-assigned identity.
   // DefaultAzureCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().build();
   
   // For user-assigned identity.
   // String clientId = System.getenv("AZURE_REDIS_CLIENTID");
   // DefaultAzureCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().managedIdentityClientId(clientId).build();
   
   // For AKS workload identity.
   // String clientId = System.getenv("AZURE_REDIS_CLIENTID");
   // DefaultAzureCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().workloadIdentityClientId(clientId).build();
   
   // For service principal.
   // String clientId = System.getenv("AZURE_REDIS_CLIENTID");
   // String secret = System.getenv("AZURE_REDIS_CLIENTSECRET");
   // String tenant = System.getenv("AZURE_REDIS_TENANTID");
   // ClientSecretCredential defaultAzureCredential = new ClientSecretCredentialBuilder().tenantId(tenant).clientId(clientId).clientSecret(secret).build();
   
   String token = defaultAzureCredential
   .getToken(new TokenRequestContext()
       .addScopes("https://redis.azure.com/.default")).block().getToken();
   
   // SSL connection is required.
   boolean useSsl = true;
   // TODO: Replace Host Name with Azure Cache for Redis Host Name.
   String username = extractUsernameFromToken(token);
   String cacheHostname = System.getenv("AZURE_REDIS_HOST");
   
   // Create Jedis client and connect to Azure Cache for Redis over the TLS/SSL port using the access token as password.
   // Note, Redis Cache host name and port are required below.
   Jedis jedis = new Jedis(cacheHostname, 6380, DefaultJedisClientConfig.builder()
       .password(token) // Microsoft Entra access token as password is required.
       .user(username) // Username is Required
       .ssl(useSsl) // SSL Connection is Required
       .build());
   
   // Set a value against your key in the Redis cache.
   jedis.set("Az:key", "testValue");
   System.out.println(jedis.get("Az:key"));
   
   // Close the Jedis Client
   jedis.close();
   

Spring Boot

Pas encore pris en charge.

Python

1. Installez des dépendances.

   pip install redis azure-identity
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’informations, consultez authentification-azure-aad-avec-redis-py.

   import os
   import time
   import logging
   import redis
   import base64
   import json
   from azure.identity import DefaultAzureCredential
   
   host = os.getenv('AZURE_REDIS_HOST')
   scope = "https://redis.azure.com/.default"
   port = 6380  # Required
   
   def extract_username_from_token(token):
       parts = token.split('.')
       base64_str = parts[1]
   
       if len(base64_str) % 4 == 2:
           base64_str += "=="
       elif len(base64_str) % 4 == 3:
           base64_str += "="
   
       json_bytes = base64.b64decode(base64_str)
       json_str = json_bytes.decode('utf-8')
       jwt = json.loads(json_str)
   
       return jwt['oid']
   
   def re_authentication():
       _LOGGER = logging.getLogger(__name__)
       # Uncomment the following lines corresponding to the authentication type you want to use.
       # For system-assigned identity.
       # cred = DefaultAzureCredential()
   
       # For user-assigned identity.
       # client_id = os.getenv('AZURE_REDIS_CLIENTID')
       # cred = DefaultAzureCredential(managed_identity_client_id=client_id)
   
       # For user-assigned identity.
       # client_id = os.getenv('AZURE_REDIS_CLIENTID')
       # cred = DefaultAzureCredential(managed_identity_client_id=client_id)
   
       # For service principal.
       # tenant_id = os.getenv("AZURE_TENANT_ID")
       # client_id = os.getenv("AZURE_CLIENT_ID")
       # client_secret = os.getenv("AZURE_CLIENT_SECRET")
       # cred = ServicePrincipalCredentials(tenant=tenant_id, client_id=client_id, secret=client_secret)
   
       token = cred.get_token(scope)
       user_name = extract_username_from_token(token.token)
       r = redis.Redis(host=host,
                       port=port,
                       ssl=True,   # ssl connection is required.
                       username=user_name,
                       password=token.token,
                       decode_responses=True)
       max_retry = 3
       for index in range(max_retry):
           try:
               if _need_refreshing(token):
                   _LOGGER.info("Refreshing token...")
                   tmp_token = cred.get_token(scope)
                   if tmp_token:
                       token = tmp_token
                   r.execute_command("AUTH", user_name, token.token)
               r.set("Az:key1", "value1")
               t = r.get("Az:key1")
               print(t)
               break
           except redis.ConnectionError:
               _LOGGER.info("Connection lost. Reconnecting.")
               token = cred.get_token(scope)
               r = redis.Redis(host=host,
                               port=port,
                               ssl=True,   # ssl connection is required.
                               username=user_name,
                               password=token.token,
                               decode_responses=True)
           except Exception:
               _LOGGER.info("Unknown failures.")
               break
   
   
   def _need_refreshing(token, refresh_offset=300):
       return not token or token.expires_on - time.time() < refresh_offset
   
   if __name__ == '__main__':
       re_authentication()
   

Go

Pas encore pris en charge.

Node.JS

1. Installez des dépendances.

   npm install redis @azure/identity
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’informations, consultez Azure Cache pour Redis : Microsoft Entra ID avec une bibliothèque de client node-redis.

   import { createClient } from "redis";
   import { DefaultAzureCredential } from "@azure/identity";
   
   function extractUsernameFromToken(accessToken: AccessToken): string{
       const base64Metadata = accessToken.token.split(".")[1];
       const { oid } = JSON.parse(
           Buffer.from(base64Metadata, "base64").toString("utf8"),
       );
       return oid;
   }
   
   async function main() {
       // Uncomment the following lines corresponding to the authentication type you want to use.  
       // For system-assigned identity.
       // const credential = new DefaultAzureCredential();
   
       // For user-assigned identity.
       // const clientId = process.env.AZURE_REDIS_CLIENTID;
       // const credential = new DefaultAzureCredential({
       //     managedIdentityClientId: clientId
       // });
   
       // For service principal.
       // const tenantId = process.env.AZURE_REDIS_TENANTID;
       // const clientId = process.env.AZURE_REDIS_CLIENTID;
       // const clientSecret = process.env.AZURE_REDIS_CLIENTSECRET;
       // const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);
   
       // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
       const redisScope = "https://redis.azure.com/.default";
       let accessToken = await credential.getToken(redisScope);
       console.log("access Token", accessToken);
       const host = process.env.AZURE_REDIS_HOST;
   
       // Create redis client and connect to Azure Cache for Redis over the TLS port using the access token as password.
       const client = createClient({
           username: extractUsernameFromToken(accessToken),
           password: accessToken.token,
           url: `redis://${host}:6380`,
           pingInterval: 100000,
           socket: { 
           tls: true,
           keepAlive: 0 
           },
       });
   
       client.on("error", (err) => console.log("Redis Client Error", err));
       await client.connect();
       // Set a value against your key in Azure Redis Cache.
       await client.set("Az:key", "value1312");
       // Get value of your key in Azure Redis Cache.
       console.log("value-", await client.get("Az:key"));
   }
   
   main().catch((err) => {
       console.log("error code: ", err.code);
       console.log("error message: ", err.message);
       console.log("error stack: ", err.stack);
   });
   

Other

Pour les autres langages, vous pouvez utiliser la bibliothèque de client Azure Identity (et les informations de connexion que le connecteur de services définit sur les variables d’environnement) pour vous connecter à Azure Cache pour Redis.

Identité managée affectée par l’utilisateur

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_REDIS_HOST	Point de terminaison Redis	<RedisName>.redis.cache.windows.net
AZURE_REDIS_CLIENTID	ID client de l’identité managée	<client-ID>

Exemple de code

Les étapes et le code suivants vous montrent comment utiliser une identité managée affectée par l’utilisateur pour se connecter à Redis.

.NET

1. Installez des dépendances.

   dotnet add package Microsoft.Azure.StackExchangeRedis --version 3.2.0
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’information, consultez Extension Microsoft.Azure.StackExchangeRedis.

   using StackExchange.Redis;
   var cacheHostName = Environment.GetEnvironmentVariable("AZURE_REDIS_HOST");
   var configurationOptions = ConfigurationOptions.Parse($"{cacheHostName}:6380");
   
   // Uncomment the following lines corresponding to the authentication type you want to use.
   // For system-assigned identity.
   // await configurationOptions.ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential());
   
   // For user-assigned identity.
   // var managedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_REDIS_CLIENTID");
   // await configurationOptions.ConfigureForAzureWithUserAssignedManagedIdentityAsync(managedIdentityClientId);
   
   // Service principal secret.
   // var clientId = Environment.GetEnvironmentVariable("AZURE_REDIS_CLIENTID");
   // var tenantId = Environment.GetEnvironmentVariable("AZURE_REDIS_TENANTID");
   // var secret = Environment.GetEnvironmentVariable("AZURE_REDIS_CLIENTSECRET");
   // await configurationOptions.ConfigureForAzureWithServicePrincipalAsync(clientId, tenantId, secret);
   
   
   var connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(configurationOptions);
   

Java

1. Ajoutez la dépendance suivante dans votre fichier pom.xml :

   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
       <version>1.11.2</version> <!-- {x-version-update;com.azure:azure-identity;dependency} -->
   </dependency>
   
   <dependency>
       <groupId>redis.clients</groupId>
       <artifactId>jedis</artifactId>
       <version>5.1.0</version>  <!-- {x-version-update;redis.clients:jedis;external_dependency} -->
   </dependency>
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’informations, consultez Authentification-Azure-AAD-avec-Jedis.

   import redis.clients.jedis.DefaultJedisClientConfig;
   import redis.clients.jedis.Jedis;
   import redis.clients.jedis.JedisShardInfo;
   import java.net.URI;
   
   // Uncomment the following lines corresponding to the authentication type you want to use.
   // For system-assigned identity.
   // DefaultAzureCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().build();
   
   // For user-assigned identity.
   // String clientId = System.getenv("AZURE_REDIS_CLIENTID");
   // DefaultAzureCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().managedIdentityClientId(clientId).build();
   
   // For AKS workload identity.
   // String clientId = System.getenv("AZURE_REDIS_CLIENTID");
   // DefaultAzureCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().workloadIdentityClientId(clientId).build();
   
   // For service principal.
   // String clientId = System.getenv("AZURE_REDIS_CLIENTID");
   // String secret = System.getenv("AZURE_REDIS_CLIENTSECRET");
   // String tenant = System.getenv("AZURE_REDIS_TENANTID");
   // ClientSecretCredential defaultAzureCredential = new ClientSecretCredentialBuilder().tenantId(tenant).clientId(clientId).clientSecret(secret).build();
   
   String token = defaultAzureCredential
   .getToken(new TokenRequestContext()
       .addScopes("https://redis.azure.com/.default")).block().getToken();
   
   // SSL connection is required.
   boolean useSsl = true;
   // TODO: Replace Host Name with Azure Cache for Redis Host Name.
   String username = extractUsernameFromToken(token);
   String cacheHostname = System.getenv("AZURE_REDIS_HOST");
   
   // Create Jedis client and connect to Azure Cache for Redis over the TLS/SSL port using the access token as password.
   // Note, Redis Cache host name and port are required below.
   Jedis jedis = new Jedis(cacheHostname, 6380, DefaultJedisClientConfig.builder()
       .password(token) // Microsoft Entra access token as password is required.
       .user(username) // Username is Required
       .ssl(useSsl) // SSL Connection is Required
       .build());
   
   // Set a value against your key in the Redis cache.
   jedis.set("Az:key", "testValue");
   System.out.println(jedis.get("Az:key"));
   
   // Close the Jedis Client
   jedis.close();
   

Spring Boot

Pas encore pris en charge.

Python

1. Installez des dépendances.

   pip install redis azure-identity
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’informations, consultez authentification-azure-aad-avec-redis-py.

   import os
   import time
   import logging
   import redis
   import base64
   import json
   from azure.identity import DefaultAzureCredential
   
   host = os.getenv('AZURE_REDIS_HOST')
   scope = "https://redis.azure.com/.default"
   port = 6380  # Required
   
   def extract_username_from_token(token):
       parts = token.split('.')
       base64_str = parts[1]
   
       if len(base64_str) % 4 == 2:
           base64_str += "=="
       elif len(base64_str) % 4 == 3:
           base64_str += "="
   
       json_bytes = base64.b64decode(base64_str)
       json_str = json_bytes.decode('utf-8')
       jwt = json.loads(json_str)
   
       return jwt['oid']
   
   def re_authentication():
       _LOGGER = logging.getLogger(__name__)
       # Uncomment the following lines corresponding to the authentication type you want to use.
       # For system-assigned identity.
       # cred = DefaultAzureCredential()
   
       # For user-assigned identity.
       # client_id = os.getenv('AZURE_REDIS_CLIENTID')
       # cred = DefaultAzureCredential(managed_identity_client_id=client_id)
   
       # For user-assigned identity.
       # client_id = os.getenv('AZURE_REDIS_CLIENTID')
       # cred = DefaultAzureCredential(managed_identity_client_id=client_id)
   
       # For service principal.
       # tenant_id = os.getenv("AZURE_TENANT_ID")
       # client_id = os.getenv("AZURE_CLIENT_ID")
       # client_secret = os.getenv("AZURE_CLIENT_SECRET")
       # cred = ServicePrincipalCredentials(tenant=tenant_id, client_id=client_id, secret=client_secret)
   
       token = cred.get_token(scope)
       user_name = extract_username_from_token(token.token)
       r = redis.Redis(host=host,
                       port=port,
                       ssl=True,   # ssl connection is required.
                       username=user_name,
                       password=token.token,
                       decode_responses=True)
       max_retry = 3
       for index in range(max_retry):
           try:
               if _need_refreshing(token):
                   _LOGGER.info("Refreshing token...")
                   tmp_token = cred.get_token(scope)
                   if tmp_token:
                       token = tmp_token
                   r.execute_command("AUTH", user_name, token.token)
               r.set("Az:key1", "value1")
               t = r.get("Az:key1")
               print(t)
               break
           except redis.ConnectionError:
               _LOGGER.info("Connection lost. Reconnecting.")
               token = cred.get_token(scope)
               r = redis.Redis(host=host,
                               port=port,
                               ssl=True,   # ssl connection is required.
                               username=user_name,
                               password=token.token,
                               decode_responses=True)
           except Exception:
               _LOGGER.info("Unknown failures.")
               break
   
   
   def _need_refreshing(token, refresh_offset=300):
       return not token or token.expires_on - time.time() < refresh_offset
   
   if __name__ == '__main__':
       re_authentication()
   

Go

Pas encore pris en charge.

Node.JS

1. Installez des dépendances.

   npm install redis @azure/identity
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’informations, consultez Azure Cache pour Redis : Microsoft Entra ID avec une bibliothèque de client node-redis.

   import { createClient } from "redis";
   import { DefaultAzureCredential } from "@azure/identity";
   
   function extractUsernameFromToken(accessToken: AccessToken): string{
       const base64Metadata = accessToken.token.split(".")[1];
       const { oid } = JSON.parse(
           Buffer.from(base64Metadata, "base64").toString("utf8"),
       );
       return oid;
   }
   
   async function main() {
       // Uncomment the following lines corresponding to the authentication type you want to use.  
       // For system-assigned identity.
       // const credential = new DefaultAzureCredential();
   
       // For user-assigned identity.
       // const clientId = process.env.AZURE_REDIS_CLIENTID;
       // const credential = new DefaultAzureCredential({
       //     managedIdentityClientId: clientId
       // });
   
       // For service principal.
       // const tenantId = process.env.AZURE_REDIS_TENANTID;
       // const clientId = process.env.AZURE_REDIS_CLIENTID;
       // const clientSecret = process.env.AZURE_REDIS_CLIENTSECRET;
       // const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);
   
       // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
       const redisScope = "https://redis.azure.com/.default";
       let accessToken = await credential.getToken(redisScope);
       console.log("access Token", accessToken);
       const host = process.env.AZURE_REDIS_HOST;
   
       // Create redis client and connect to Azure Cache for Redis over the TLS port using the access token as password.
       const client = createClient({
           username: extractUsernameFromToken(accessToken),
           password: accessToken.token,
           url: `redis://${host}:6380`,
           pingInterval: 100000,
           socket: { 
           tls: true,
           keepAlive: 0 
           },
       });
   
       client.on("error", (err) => console.log("Redis Client Error", err));
       await client.connect();
       // Set a value against your key in Azure Redis Cache.
       await client.set("Az:key", "value1312");
       // Get value of your key in Azure Redis Cache.
       console.log("value-", await client.get("Az:key"));
   }
   
   main().catch((err) => {
       console.log("error code: ", err.code);
       console.log("error message: ", err.message);
       console.log("error stack: ", err.stack);
   });
   

Other

Pour les autres langages, vous pouvez utiliser la bibliothèque de client Azure Identity (et les informations de connexion que le connecteur de services définit sur les variables d’environnement) pour vous connecter à Azure Cache pour Redis.

Chaîne de connexion

Avertissement

Nous vous recommandons d’utiliser le flux d’authentification le plus sécurisé disponible. Le flux d’authentification décrit ici nécessite un degré très élevé de confiance dans l’application et comporte des risques qui ne sont pas présents dans les autres flux. Vous devez utiliser ce flux seulement si des flux plus sécurisés, tels que les identités managées, ne sont pas viables.

.NET

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_REDIS_CONNECTIONSTRING	Chaîne de connexion StackExchange.Redis	<redis-server-name>.redis.cache.windows.net:6380,password=<redis-key>,ssl=True,defaultDatabase=0

Java

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_REDIS_CONNECTIONSTRING	Chaîne de connexion Jedis	rediss://:<redis-key>@<redis-server-name>.redis.cache.windows.net:6380/0

Spring Boot

Propriétés de l’application	Description	Exemple de valeur
spring.redis.host	Hôte Redis	<redis-server-name>.redis.cache.windows.net
spring.redis.port	Port Redis	6380
spring.redis.database	Base de données Redis	0
spring.redis.password	Clé Redis	<redis-key>
spring.redis.ssl	Paramètre SSL	true

Python

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_REDIS_CONNECTIONSTRING	Chaîne de connexion redis-py	rediss://:<redis-key>@<redis-server-name>.redis.cache.windows.net:6380/0

Go

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_REDIS_CONNECTIONSTRING	Chaîne de connexion redis-py	rediss://:<redis-key>@<redis-server-name>.redis.cache.windows.net:6380/0

Node.JS

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_REDIS_CONNECTIONSTRING	Chaîne de connexion node-redis	rediss://:<redis-key>@<redis-server-name>.redis.cache.windows.net:6380/0

Other

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_REDIS_HOST	Hôte Redis	<redis-server-name>.redis.cache.windows.net
AZURE_REDIS_PORT	Port Redis	6380
AZURE_REDIS_DATABASE	Base de données Redis	0
AZURE_REDIS_PASSWORD	Clé Redis	<redis-key>
AZURE_REDIS_SSL	Paramètre SSL	true

Exemple de code

Les étapes et le code suivants vous montrent comment utiliser une chaîne de connexion pour vous connecter à Azure Cache pour Redis.

.NET

1. Installez des dépendances.

   dotnet add package StackExchange.Redis --version 2.6.122
   

2. Obtenez la chaîne de connexion à partir de la variable d’environnement ajoutée par le connecteur de services.

   using StackExchange.Redis;
   var connectionString = Environment.GetEnvironmentVariable("AZURE_REDIS_CONNECTIONSTRING");
   var _redisConnection = await RedisConnection.InitializeAsync(connectionString: connectionString);
   

Java

1. Ajoutez la dépendance suivante dans votre fichier pom.xml :

   <dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>4.1.0</version>
     <type>jar</type>
     <scope>compile</scope>
   </dependency>
   

2. Obtenez la chaîne de connexion à partir de la variable d’environnement ajoutée par le connecteur de services.

   import redis.clients.jedis.DefaultJedisClientConfig;
   import redis.clients.jedis.Jedis;
   import redis.clients.jedis.JedisShardInfo;
   import java.net.URI;
   
   String connectionString = System.getenv("AZURE_REDIS_CONNECTIONSTRING");
   URI uri = new URI(connectionString);
   JedisShardInfo shardInfo = new JedisShardInfo(uri);
   shardInfo.setSsl(true);
   Jedis jedis = new Jedis(shardInfo);
   

Spring Boot

Pour configurer votre application Spring, consultez Utiliser Azure Cache pour Redis dans Spring. Le connecteur de services ajoute les propriétés de configuration à Spring Apps.

Python

1. Installez des dépendances.

   pip install redis
   

2. Obtenez la chaîne de connexion à partir de la variable d’environnement ajoutée par le connecteur de services.

   import os
   import redis
   
   url = os.getenv('AZURE_REDIS_CONNECTIONSTRING')
   url_connection = redis.from_url(url)
   url_connection.ping()
   

Go

1. Installez des dépendances.

   go get github.com/redis/go-redis/v9
   

2. Obtenez la chaîne de connexion à partir de la variable d’environnement ajoutée par le connecteur de services.

   import (
       "context"
       "fmt"
   
       "github.com/redis/go-redis/v9"
   )
   
   connectionString := os.Getenv("AZURE_REDIS_CONNECTIONSTRING")
   opt, err := redis.ParseURL(connectionString)
   if err != nil {
   	panic(err)
   }
   
   client := redis.NewClient(opt)
   

Node.JS

1. Installez des dépendances.

   npm install redis
   

2. Obtenez la chaîne de connexion à partir de la variable d’environnement ajoutée par le connecteur de services.

   const redis = require("redis");
   
   const connectionString = process.env.AZURE_REDIS_CONNECTIONSTRING;
   const cacheConnection = redis.createClient({
       url: connectionString,
   });
   await cacheConnection.connect();
   

Other

Pour les autres langages, vous pouvez utiliser les informations de connexion que le connecteur de services définit sur les variables d’environnement pour vous connecter à Azure Cache pour Redis.

Principal du service

Nom de variable d’environnement par défaut	Description	Exemple de valeur
AZURE_REDIS_HOST	Point de terminaison Redis	<RedisName>.redis.cache.windows.net
AZURE_REDIS_CLIENTID	ID client du principal de service	<client-ID>
AZURE_REDIS_CLIENTSECRET	Secret du principal de service	<client-secret>
AZURE_REDIS_TENANTID	ID de locataire du principal de service	<tenant-id>

Exemple de code

Les étapes et le code suivants vous montrent comment utiliser un principal de service pour vous connecter à Redis.

.NET

1. Installez des dépendances.

   dotnet add package Microsoft.Azure.StackExchangeRedis --version 3.2.0
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’information, consultez Extension Microsoft.Azure.StackExchangeRedis.

   using StackExchange.Redis;
   var cacheHostName = Environment.GetEnvironmentVariable("AZURE_REDIS_HOST");
   var configurationOptions = ConfigurationOptions.Parse($"{cacheHostName}:6380");
   
   // Uncomment the following lines corresponding to the authentication type you want to use.
   // For system-assigned identity.
   // await configurationOptions.ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential());
   
   // For user-assigned identity.
   // var managedIdentityClientId = Environment.GetEnvironmentVariable("AZURE_REDIS_CLIENTID");
   // await configurationOptions.ConfigureForAzureWithUserAssignedManagedIdentityAsync(managedIdentityClientId);
   
   // Service principal secret.
   // var clientId = Environment.GetEnvironmentVariable("AZURE_REDIS_CLIENTID");
   // var tenantId = Environment.GetEnvironmentVariable("AZURE_REDIS_TENANTID");
   // var secret = Environment.GetEnvironmentVariable("AZURE_REDIS_CLIENTSECRET");
   // await configurationOptions.ConfigureForAzureWithServicePrincipalAsync(clientId, tenantId, secret);
   
   
   var connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(configurationOptions);
   

Java

1. Ajoutez la dépendance suivante dans votre fichier pom.xml :

   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
       <version>1.11.2</version> <!-- {x-version-update;com.azure:azure-identity;dependency} -->
   </dependency>
   
   <dependency>
       <groupId>redis.clients</groupId>
       <artifactId>jedis</artifactId>
       <version>5.1.0</version>  <!-- {x-version-update;redis.clients:jedis;external_dependency} -->
   </dependency>
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’informations, consultez Authentification-Azure-AAD-avec-Jedis.

   import redis.clients.jedis.DefaultJedisClientConfig;
   import redis.clients.jedis.Jedis;
   import redis.clients.jedis.JedisShardInfo;
   import java.net.URI;
   
   // Uncomment the following lines corresponding to the authentication type you want to use.
   // For system-assigned identity.
   // DefaultAzureCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().build();
   
   // For user-assigned identity.
   // String clientId = System.getenv("AZURE_REDIS_CLIENTID");
   // DefaultAzureCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().managedIdentityClientId(clientId).build();
   
   // For AKS workload identity.
   // String clientId = System.getenv("AZURE_REDIS_CLIENTID");
   // DefaultAzureCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().workloadIdentityClientId(clientId).build();
   
   // For service principal.
   // String clientId = System.getenv("AZURE_REDIS_CLIENTID");
   // String secret = System.getenv("AZURE_REDIS_CLIENTSECRET");
   // String tenant = System.getenv("AZURE_REDIS_TENANTID");
   // ClientSecretCredential defaultAzureCredential = new ClientSecretCredentialBuilder().tenantId(tenant).clientId(clientId).clientSecret(secret).build();
   
   String token = defaultAzureCredential
   .getToken(new TokenRequestContext()
       .addScopes("https://redis.azure.com/.default")).block().getToken();
   
   // SSL connection is required.
   boolean useSsl = true;
   // TODO: Replace Host Name with Azure Cache for Redis Host Name.
   String username = extractUsernameFromToken(token);
   String cacheHostname = System.getenv("AZURE_REDIS_HOST");
   
   // Create Jedis client and connect to Azure Cache for Redis over the TLS/SSL port using the access token as password.
   // Note, Redis Cache host name and port are required below.
   Jedis jedis = new Jedis(cacheHostname, 6380, DefaultJedisClientConfig.builder()
       .password(token) // Microsoft Entra access token as password is required.
       .user(username) // Username is Required
       .ssl(useSsl) // SSL Connection is Required
       .build());
   
   // Set a value against your key in the Redis cache.
   jedis.set("Az:key", "testValue");
   System.out.println(jedis.get("Az:key"));
   
   // Close the Jedis Client
   jedis.close();
   

Spring Boot

Pas encore pris en charge.

Python

1. Installez des dépendances.

   pip install redis azure-identity
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’informations, consultez authentification-azure-aad-avec-redis-py.

   import os
   import time
   import logging
   import redis
   import base64
   import json
   from azure.identity import DefaultAzureCredential
   
   host = os.getenv('AZURE_REDIS_HOST')
   scope = "https://redis.azure.com/.default"
   port = 6380  # Required
   
   def extract_username_from_token(token):
       parts = token.split('.')
       base64_str = parts[1]
   
       if len(base64_str) % 4 == 2:
           base64_str += "=="
       elif len(base64_str) % 4 == 3:
           base64_str += "="
   
       json_bytes = base64.b64decode(base64_str)
       json_str = json_bytes.decode('utf-8')
       jwt = json.loads(json_str)
   
       return jwt['oid']
   
   def re_authentication():
       _LOGGER = logging.getLogger(__name__)
       # Uncomment the following lines corresponding to the authentication type you want to use.
       # For system-assigned identity.
       # cred = DefaultAzureCredential()
   
       # For user-assigned identity.
       # client_id = os.getenv('AZURE_REDIS_CLIENTID')
       # cred = DefaultAzureCredential(managed_identity_client_id=client_id)
   
       # For user-assigned identity.
       # client_id = os.getenv('AZURE_REDIS_CLIENTID')
       # cred = DefaultAzureCredential(managed_identity_client_id=client_id)
   
       # For service principal.
       # tenant_id = os.getenv("AZURE_TENANT_ID")
       # client_id = os.getenv("AZURE_CLIENT_ID")
       # client_secret = os.getenv("AZURE_CLIENT_SECRET")
       # cred = ServicePrincipalCredentials(tenant=tenant_id, client_id=client_id, secret=client_secret)
   
       token = cred.get_token(scope)
       user_name = extract_username_from_token(token.token)
       r = redis.Redis(host=host,
                       port=port,
                       ssl=True,   # ssl connection is required.
                       username=user_name,
                       password=token.token,
                       decode_responses=True)
       max_retry = 3
       for index in range(max_retry):
           try:
               if _need_refreshing(token):
                   _LOGGER.info("Refreshing token...")
                   tmp_token = cred.get_token(scope)
                   if tmp_token:
                       token = tmp_token
                   r.execute_command("AUTH", user_name, token.token)
               r.set("Az:key1", "value1")
               t = r.get("Az:key1")
               print(t)
               break
           except redis.ConnectionError:
               _LOGGER.info("Connection lost. Reconnecting.")
               token = cred.get_token(scope)
               r = redis.Redis(host=host,
                               port=port,
                               ssl=True,   # ssl connection is required.
                               username=user_name,
                               password=token.token,
                               decode_responses=True)
           except Exception:
               _LOGGER.info("Unknown failures.")
               break
   
   
   def _need_refreshing(token, refresh_offset=300):
       return not token or token.expires_on - time.time() < refresh_offset
   
   if __name__ == '__main__':
       re_authentication()
   

Go

Pas encore pris en charge.

Node.JS

1. Installez des dépendances.

   npm install redis @azure/identity
   

2. Ajoutez la logique d’authentification avec les variables d’environnement définies par le connecteur de services. Pour plus d’informations, consultez Azure Cache pour Redis : Microsoft Entra ID avec une bibliothèque de client node-redis.

   import { createClient } from "redis";
   import { DefaultAzureCredential } from "@azure/identity";
   
   function extractUsernameFromToken(accessToken: AccessToken): string{
       const base64Metadata = accessToken.token.split(".")[1];
       const { oid } = JSON.parse(
           Buffer.from(base64Metadata, "base64").toString("utf8"),
       );
       return oid;
   }
   
   async function main() {
       // Uncomment the following lines corresponding to the authentication type you want to use.  
       // For system-assigned identity.
       // const credential = new DefaultAzureCredential();
   
       // For user-assigned identity.
       // const clientId = process.env.AZURE_REDIS_CLIENTID;
       // const credential = new DefaultAzureCredential({
       //     managedIdentityClientId: clientId
       // });
   
       // For service principal.
       // const tenantId = process.env.AZURE_REDIS_TENANTID;
       // const clientId = process.env.AZURE_REDIS_CLIENTID;
       // const clientSecret = process.env.AZURE_REDIS_CLIENTSECRET;
       // const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);
   
       // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
       const redisScope = "https://redis.azure.com/.default";
       let accessToken = await credential.getToken(redisScope);
       console.log("access Token", accessToken);
       const host = process.env.AZURE_REDIS_HOST;
   
       // Create redis client and connect to Azure Cache for Redis over the TLS port using the access token as password.
       const client = createClient({
           username: extractUsernameFromToken(accessToken),
           password: accessToken.token,
           url: `redis://${host}:6380`,
           pingInterval: 100000,
           socket: { 
           tls: true,
           keepAlive: 0 
           },
       });
   
       client.on("error", (err) => console.log("Redis Client Error", err));
       await client.connect();
       // Set a value against your key in Azure Redis Cache.
       await client.set("Az:key", "value1312");
       // Get value of your key in Azure Redis Cache.
       console.log("value-", await client.get("Az:key"));
   }
   
   main().catch((err) => {
       console.log("error code: ", err.code);
       console.log("error message: ", err.message);
       console.log("error stack: ", err.stack);
   });
   

Other

Pour les autres langages, vous pouvez utiliser la bibliothèque de client Azure Identity (et les informations de connexion que le connecteur de services définit sur les variables d’environnement) pour vous connecter à Azure Cache pour Redis.

Contenu connexe

• En savoir plus sur les concepts Service Connector