Skip to main content

Configurer la réutilisation des connexions pour le SDK DashScope

Sans réutilisation des connexions, chaque appel API ouvre une nouvelle connexion TCP et exécute une négociation TLS, ce qui accroît la latence. Dans les scénarios à forte concurrence, cette surcharge entraîne des délais d'attente et un gaspillage de ressources. La réutilisation des connexions évite ces initialisations répétées, réduisant ainsi la latence et la consommation de ressources.

Le SDK DashScope prend en charge la réutilisation des connexions pour Java et Python :
  • SDK Java : Un pool de connexions intégré est activé par défaut. Configurez des paramètres tels que le nombre maximal de connexions et les délais d'attente.
  • SDK Python : Activez la réutilisation des connexions en transmettant une Session personnalisée. Cette méthode fonctionne aussi bien pour les appels synchrones qu'asynchrones.

Prérequis

Avant d'exécuter les exemples de code :
  1. Exporter la clé API en tant que variable d'environnement.
  2. Installer la dernière version du SDK.

SDK Java

Le SDK Java intègre un pool de connexions activé par défaut. Ajustez le nombre maximal de connexions et les délais d'attente afin d'optimiser les performances selon votre charge de travail.

Paramètres

ParamètreDescriptionValeur par défautUnité
connectTimeoutDélai d'établissement de la connexion.120secondes
readTimeoutDélai de lecture des données.300secondes
writeTimeoutDélai d'écriture des données.60secondes
connectionIdleTimeoutDélai d'inactivité des connexions dans le pool.300secondes
connectionPoolSizeNombre maximal de connexions dans le pool.32connexions
maximumAsyncRequestsNombre maximal de requêtes simultanées sur tous les hôtes (limite globale).32requêtes
maximumAsyncRequestsPerHostNombre maximal de requêtes simultanées par hôte.32requêtes
Contraintes des paramètres :
  • La valeur de maximumAsyncRequests doit être ≤ connectionPoolSize ; sinon, les requêtes risquent d'être bloquées.
  • La valeur de maximumAsyncRequestsPerHost doit être ≤ maximumAsyncRequests.
Recommandations d'ajustement :
  • connectTimeout : Pour les scénarios nécessitant une faible latence, définissez un délai plus court afin de réduire le temps d'attente.
  • connectionIdleTimeout : En cas de forte concurrence, augmentez le délai d'inactivité pour éviter la création fréquente de connexions et limiter la consommation de ressources.
  • connectionPoolSize : Dans un contexte de forte concurrence, un nombre insuffisant de connexions entraîne des blocages, des délais d'attente et des reconnexions fréquentes (augmentation de l'utilisation des ressources). À l'inverse, trop de connexions peuvent surcharger le serveur. Équilibrez ce nombre en fonction de votre charge de travail.

Exemple de code

L'exemple suivant configure les paramètres du pool de connexions (délais d'attente, nombre maximal de connexions) et appelle un service de modèle. Ajustez ces paramètres pour optimiser la concurrence et l'utilisation des ressources.
// Recommended DashScope SDK version >= 2.12.0
import java.time.Duration;
import java.util.Arrays;

import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.protocol.ConnectionConfigurations;
import com.alibaba.dashscope.protocol.Protocol;
import com.alibaba.dashscope.utils.Constants;

public class Main {
    public static GenerationResult callWithMessage() throws ApiException, NoApiKeyException, InputRequiredException {
        // This is the Singapore region URL. Replace WorkspaceId with your actual workspace ID. URLs differ by region.
        Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1");
        Message systemMsg = Message.builder()
                .role(Role.SYSTEM.getValue())
                .content("You are a helpful assistant.")
                .build();
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content("Who are you?")
                .build();
        GenerationParam param = GenerationParam.builder()
                // API keys for Singapore and Beijing regions differ. Get an API key: https://www.alibabacloud.com/help/en/model-studio/get-api-key
                // If you have not configured the environment variable, replace the following line with your Model Studio API key: .apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                // This example uses qwen-plus. Change the model name as needed. Model list: https://www.alibabacloud.com/help/en/model-studio/getting-started/models
                .model("qwen-plus")
                .messages(Arrays.asList(systemMsg, userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .build();

        System.out.println(userMsg.getContent());
        return gen.call(param);
    }
    public static void main(String[] args) {
        // Connection pool configuration
        Constants.connectionConfigurations = ConnectionConfigurations.builder()
                .connectTimeout(Duration.ofSeconds(10))  // Timeout for establishing a connection, default 120s
                .readTimeout(Duration.ofSeconds(300)) // Timeout for reading data, default 300s
                .writeTimeout(Duration.ofSeconds(60)) // Timeout for writing data, default 60s
                .connectionIdleTimeout(Duration.ofSeconds(300)) // Timeout for idle connections in the connection pool, default 300s
                .connectionPoolSize(256) // Maximum connections in the connection pool, default 32
                .maximumAsyncRequests(256)  // Maximum concurrent requests, default 32
                .maximumAsyncRequestsPerHost(256) // Maximum concurrent requests per host, default 32
                .build();

        try {
            GenerationResult result = callWithMessage();
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent());
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            // Use a logging framework to record exception information
            System.err.println("An error occurred while calling the generation service: " + e.getMessage());
        }
        System.exit(0);
    }
}

SDK Python

Le SDK Python DashScope permet la réutilisation des connexions en transmettant un client HTTP personnalisé (httpx.Client / httpx.AsyncClient). Deux modes d'appel sont disponibles : HTTP asynchrone (basé sur des coroutines) et HTTP synchrone.

HTTP asynchrone

Pour les scénarios asynchrones, utilisez httpx.AsyncClient avec httpx.Limits afin d'activer la réutilisation des connexions. httpx.Limits permet de configurer des paramètres tels que les limites de connexion :
ParamètreDescriptionValeur par défautNotes
max_connectionsLimite totale de connexions.None (illimité)Contrôle le nombre maximal de connexions. Dans les scénarios à forte concurrence, augmentez cette valeur pour améliorer le parallélisme.
max_keepalive_connectionsNombre maximal de connexions keep-alive.None (illimité)Contrôle le nombre de connexions actives maintenues dans le pool, évitant une charge excessive sur un serveur unique.
keepalive_expiryDurée de maintien en vie (keep-alive) des connexions.5.0 (secondes)Les connexions keep-alive inactives sont automatiquement fermées au-delà de cette durée.

Exemple de code

L'exemple ci-dessous configure la réutilisation des connexions et appelle un service de modèle de manière asynchrone :
import asyncio
import httpx
import os
import dashscope

async def main():
    # Configurez les paramètres de connexion
    limits = httpx.Limits(
        max_connections=100,           # Limite totale de connexions
        max_keepalive_connections=30,  # Nombre maximum de connexions keep-alive
    )

    # Créez un client HTTP personnalisé et transmettez-le au constructeur de Client
    async with httpx.AsyncClient(limits=limits) as http_client:
        # Voici la configuration de la région de Singapour. Remplacez {WorkspaceId} par l'ID de votre workspace. La valeur de region varie selon la région.
        # L'API Key de la région de Singapour est différente de celle de la région de Pékin. Obtenez une API Key : https://www.alibabacloud.com/help/model-studio/get-api-key
        # Si la variable d'environnement n'est pas configurée, définissez votre API key directement : api_key = "sk-xxx"
        aclient = dashscope.AsyncClient(
            api_key=os.getenv("DASHSCOPE_API_KEY"),
            workspace="{WorkspaceId}",
            region="ap-southeast-1",
            http_client=http_client,  # Transmettez le client HTTP personnalisé
        )
        response = await aclient.chat.completions.create(
            model='qwen-plus',
            messages=[{"role": "user", "content": 'Hello, please introduce yourself'}],
        )
        print(response)

asyncio.run(main())

HTTP synchrone

Pour les scénarios synchrones, utilisez httpx.Client pour activer la réutilisation des connexions. Plusieurs requêtes au sein d'un même client HTTP réutilisent la connexion TCP sous-jacente, évitant ainsi la surcharge liée aux établissements répétés de connexions.

Exemple de code : appel unique

L'exemple suivant configure la réutilisation des connexions et appelle un service de modèle de manière synchrone :
import httpx
import os
import dashscope

# Utilisez l'instruction with pour garantir la fermeture correcte du client HTTP
with httpx.Client() as http_client:
    # Voici la configuration de la région de Singapour. Remplacez {WorkspaceId} par l'ID de votre workspace. La valeur de region varie selon la région.
    # L'API Key de la région de Singapour est différente de celle de la région de Pékin. Obtenez une API Key : https://www.alibabacloud.com/help/model-studio/get-api-key
    # Si la variable d'environnement n'est pas configurée, définissez votre API key directement : api_key = "sk-xxx"
    client = dashscope.Client(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        workspace="{WorkspaceId}",
        region="ap-southeast-1",
        http_client=http_client,  # Transmettez le client HTTP personnalisé
    )
    response = client.chat.completions.create(
        model='qwen-plus',
        messages=[{"role": "user", "content": 'Hello'}],
    )
    print(response)

Exemple de code : appels multiples avec une Session partagée

Pour réutiliser une Session lors de plusieurs appels :
import httpx
import os
import dashscope

# Créez un objet client HTTP et configurez les paramètres de réutilisation des connexions
http_client = httpx.Client(
    limits=httpx.Limits(
        max_connections=100,          # Limite totale de connexions
        max_keepalive_connections=30, # Nombre maximum de connexions keep-alive
    ),
)

# Voici la configuration de la région de Singapour. Remplacez {WorkspaceId} par l'ID de votre workspace. La valeur de region varie selon la région.
# L'API Key de la région de Singapour est différente de celle de la région de Pékin. Obtenez une API Key : https://www.alibabacloud.com/help/model-studio/get-api-key
# Si la variable d'environnement n'est pas configurée, définissez votre API key directement : api_key = "sk-xxx"
client = dashscope.Client(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    workspace="{WorkspaceId}",
    region="ap-southeast-1",
    http_client=http_client,  # Transmettez le client HTTP personnalisé
)

try:
    # Réutilisez le même client HTTP pour plusieurs appels
    response1 = client.chat.completions.create(
        model='qwen-plus',
        messages=[{"role": "user", "content": 'Hello'}],
    )
    print(response1)

    response2 = client.chat.completions.create(
        model='qwen-plus',
        messages=[{"role": "user", "content": 'Introduce yourself'}],
    )
    print(response2)
finally:
    # Assurez la fermeture correcte du client HTTP
    http_client.close()

Bonnes pratiques

  • SDK Java : Définissez connectionPoolSize et maximumAsyncRequests en fonction de votre charge de travail. Trouvez le bon équilibre pour le nombre de connexions : trop peu entraînent des blocages, tandis qu'un excès surcharge le serveur.
  • SDK Python : Utilisez l'instruction with pour gérer le cycle de vie du client HTTP et garantir la libération correcte des ressources.
  • Choix de la méthode appropriée : Privilégiez les appels asynchrones pour les applications asynchrones (asyncio, FastAPI). Réservez les appels synchrones aux applications traditionnelles.

Codes d'erreur

En cas d'échec d'un appel de modèle, consultez la rubrique Messages d'erreur pour résoudre le problème.