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

Cette page présente les méthodes d’authentification et les clients pris en charge, et présente des exemples de code que vous pouvez utiliser pour connecter Azure Cache pour Redis à d’autres services cloud en utilisant le connecteur de services. Vous pouvez toujours vous connecter à Azure Cache pour Redis dans d’autres langages de programmation sans utiliser le connecteur de services. Cette page présente également les noms et les valeurs des variables d’environnement par défaut (ou configuration Spring Boot) que vous obtenez lorsque vous créez des connexions de service.

Service de calcul pris en charge

Le connecteur de services peut être utilisé 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 clients pris en charge

Le tableau ci-dessous 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 » indique que la combinaison est prise en charge, tandis que « Non » indique 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

Ce tableau indique que la seule méthode d’authentification prise en charge pour tous les types clients dans le tableau est la méthode par secret/chaîne de connexion. D’autres méthodes d’authentification ne sont prises en charge pour aucun type client pour se connecter à Azure Cache pour Redis à l’aide du connecteur de services.

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 répertoriées ci-dessous pour connecter des services de calcul au serveur Redis. Pour chaque exemple ci-dessous, remplacez les textes des espaces réservés <redis-server-name> et <redis-key> par le nom et la clé de votre propre serveur Redis. Pour plus d’informations 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

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Redis à l’aide d’une identité managée affectée par le système.

.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 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 the 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();
   

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

NodeJS

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)[https://aka.ms/redis/aad/sample-code/js-noderedis].

   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 the 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 the Azure Redis Cache.
       await client.set("Az:key", "value1312");
       // Get value of your key in the 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);
   });
   

Autres

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

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Redis à l’aide d’une identité managée affectée par l’utilisateur.

.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 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 the 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();
   

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

NodeJS

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)[https://aka.ms/redis/aad/sample-code/js-noderedis].

   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 the 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 the Azure Redis Cache.
       await client.set("Az:key", "value1312");
       // Get value of your key in the 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);
   });
   

Autres

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

Microsoft vous recommande d’utiliser le flux d’authentification le plus sécurisé disponible. Le flux d'authentification décrit dans cette procédure demande un degré de confiance très élevé dans l'application et comporte des risques qui ne sont pas présents dans d'autres flux. Vous ne devez utiliser ce flux que si d’autres 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	Valeur d'exemple
AZURE_REDIS_CONNECTIONSTRING	StackExchange. Chaîne de connexion 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	Valeur d'exemple
AZURE_REDIS_CONNECTIONSTRING	Chaîne de connexion Jedis	rediss://:<redis-key>@<redis-server-name>.redis.cache.windows.net:6380/0

SpringBoot

Propriétés de l’application	Description	Valeur d'exemple
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	Valeur d'exemple
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	Valeur d'exemple
AZURE_REDIS_CONNECTIONSTRING	Chaîne de connexion redis-py	rediss://:<redis-key>@<redis-server-name>.redis.cache.windows.net:6380/0

NodeJS

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

Autres

Nom de variable d’environnement par défaut	Description	Valeur d'exemple
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

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Azure Cache pour Redis à l’aide d’une chaîne de connexion.

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

SpringBoot

Reportez-vous à Utiliser Azure Cache pour Redis dans Spring pour configurer votre application Spring. Les propriétés de configuration sont ajoutées à Spring Apps par le connecteur de services.

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)
   

NodeJS

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

Autres

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

Reportez-vous aux étapes et au code ci-dessous pour vous connecter à Redis à l’aide d’un principal de service.

.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 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 the 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();
   

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

NodeJS

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)[https://aka.ms/redis/aad/sample-code/js-noderedis].

   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 the 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 the Azure Redis Cache.
       await client.set("Az:key", "value1312");
       // Get value of your key in the 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);
   });
   

Autres

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.

Étapes suivantes

Suivez les tutoriels ci-dessous pour en savoir plus sur Service Connector.

En savoir plus sur les concepts Service Connector