Alibaba Cloud Model Studio:Configurar la reutilización de conexiones para el SDK de DashScope

Sin la reutilización de conexiones, cada llamada a la API abre una nueva conexión TCP y realiza un protocolo de enlace TLS, lo que añade latencia. En escenarios de alta concurrencia, esta sobrecarga provoca tiempos de espera y desperdicio de recursos. La reutilización de conexiones elimina la configuración repetida, reduciendo la latencia y el consumo de recursos.

El SDK de DashScope admite la reutilización de conexiones tanto en Java como en Python:

• SDK de Java: Un grupo de conexiones integrado está habilitado de forma predeterminada. Configure parámetros como el máximo de conexiones y los tiempos de espera.
• SDK de Python: Habilite la reutilización de conexiones pasando una Session personalizada. Admite llamadas síncronas y asíncronas.

Antes de comenzar

Antes de ejecutar los ejemplos de código:

1. Exporte la clave de API como variable de entorno.
2. Instale el SDK más reciente.

SDK de Java

El SDK de Java incluye un grupo de conexiones integrado habilitado de forma predeterminada. Ajuste las configuraciones de conexiones máximas y tiempos de espera para optimizar su carga de trabajo.

Parámetros

Parámetro	Descripción	Valor predeterminado	Unidad
connectTimeout	Tiempo de espera de establecimiento de conexión.	120	segundos
readTimeout	Tiempo de espera de lectura de datos.	300	segundos
writeTimeout	Tiempo de espera de escritura de datos.	60	segundos
connectionIdleTimeout	Tiempo de espera de conexión inactiva en el pool.	300	segundos
connectionPoolSize	Número máximo de conexiones en el pool.	32	conexiones
maximumAsyncRequests	Número máximo de solicitudes simultáneas en todos los hosts (límite global).	32	solicitudes
maximumAsyncRequestsPerHost	Número máximo de solicitudes simultáneas por host.	32	solicitudes

Restricciones de parámetros:

• maximumAsyncRequests debe ser ≤ connectionPoolSize; de lo contrario, las solicitudes podrían bloquearse.
• maximumAsyncRequestsPerHost debe ser ≤ maximumAsyncRequests.

Directrices de ajuste:

• connectTimeout: En escenarios de baja latencia, establezca un tiempo de espera más corto para reducir el tiempo de espera.
• connectionIdleTimeout: En escenarios de alta concurrencia, extienda el tiempo de espera de inactividad para evitar la creación frecuente de conexiones y reducir el consumo de recursos.
• connectionPoolSize: En escenarios de alta concurrencia, muy pocas conexiones causan bloqueos, tiempos de espera y reconexiones frecuentes (mayor uso de recursos). Demasiadas conexiones sobrecargan el servidor. Equilibre el recuento de conexiones según su carga de trabajo.

Ejemplo de código

El siguiente ejemplo configura los parámetros del grupo de conexiones (tiempo de espera, conexiones máximas) y llama a un servicio de modelo. Ajuste los parámetros para optimizar la concurrencia y el uso de recursos.

// 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/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/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 de Python

El SDK de Python admite la reutilización de conexiones al pasar una Session personalizada. Admite dos métodos de llamada: HTTP asíncrono (basado en corrutinas) y HTTP síncrono.

HTTP asíncrono

Para escenarios asíncronos, use aiohttp.ClientSession con aiohttp.TCPConnector para habilitar la reutilización de conexiones. TCPConnector admite la configuración de parámetros como límites de conexión:

Parámetro	Descripción	Valor predeterminado	Notas
limit	Límite total de conexiones (todos los hosts).	100	En escenarios de alta concurrencia, aumente este valor para mejorar la concurrencia.
limit_per_host	Límite de conexiones por host.	0 (ilimitado)	Evita una carga excesiva en un solo host.
ssl	Configuración del contexto SSL.	None	Validación de certificado SSL para HTTPS.

Ejemplo de código

El siguiente ejemplo configura la reutilización de conexiones y llama a un servicio de modelo de forma asíncrona:

import asyncio
import aiohttp
import ssl
import certifi
from dashscope import AioGeneration
import dashscope
import os

async def main():
    # This is the Singapore region URL. Replace WorkspaceId with your actual workspace ID. URLs differ by region.
    dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

    # API keys for Singapore and Beijing regions differ. Get an API key: https://www.alibabacloud.com/help/model-studio/get-api-key
    # If you have not configured the environment variable, replace the following line with your Model Studio API key: dashscope.api_key = "sk-xxx"
    dashscope.api_key = os.getenv("DASHSCOPE_API_KEY")

    # Configure connection parameters
    connector = aiohttp.TCPConnector(
        limit=100,           # Total connection limit
        limit_per_host=30,   # Connection limit per host
        ssl=ssl.create_default_context(cafile=certifi.where()),
    )

    # Create a custom Session and pass it to the call method
    async with aiohttp.ClientSession(connector=connector) as session:
        response = await AioGeneration.call(
            model='qwen-plus',
            prompt='Hello, please introduce yourself',
            session=session,  # Pass the custom Session
        )
        print(response)

asyncio.run(main())

HTTP síncrono

Para escenarios síncronos, use requests.Session para habilitar la reutilización de conexiones. Múltiples solicitudes dentro de la misma Session reutilizan la conexión TCP subyacente, evitando la sobrecarga de establecer conexiones repetidamente.

Ejemplo de código: llamada única

El siguiente ejemplo configura la reutilización de conexiones y llama a un servicio de modelo de forma síncrona:

import requests
from dashscope import Generation
import dashscope
import os

# This is the Singapore region URL. Replace WorkspaceId with your actual workspace ID. URLs differ by region.
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

# API keys for Singapore and Beijing regions differ. Get an API key: https://www.alibabacloud.com/help/model-studio/get-api-key
# If you have not configured the environment variable, replace the following line with your Model Studio API key: dashscope.api_key = "sk-xxx"
dashscope.api_key = os.getenv("DASHSCOPE_API_KEY")

# Use with statement to ensure Session closes correctly
with requests.Session() as session:
    response = Generation.call(
        model='qwen-plus',
        prompt='Hello',
        session=session  # Pass the custom Session
    )
    print(response)

Ejemplo de código: múltiples llamadas con una Session compartida

Para reutilizar una Session en múltiples llamadas:

import requests
from dashscope import Generation
import dashscope
import os

# This is the Singapore region URL. Replace WorkspaceId with your actual workspace ID. URLs differ by region.
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

# API keys for Singapore and Beijing regions differ. Get an API key: https://www.alibabacloud.com/help/model-studio/get-api-key
# If you have not configured the environment variable, replace the following line with your Model Studio API key: dashscope.api_key = "sk-xxx"
dashscope.api_key = os.getenv("DASHSCOPE_API_KEY")

# Create a Session object
session = requests.Session()

try:
    # Reuse the same Session for multiple calls
    response1 = Generation.call(
        model='qwen-plus',
        prompt='Hello',
        session=session
    )
    print(response1)

    response2 = Generation.call(
        model='qwen-plus',
        prompt='Introduce yourself',
        session=session
    )
    print(response2)
finally:
    # Ensure Session closes correctly
    session.close()

Mejores prácticas

• SDK de Java: Establezca connectionPoolSize y maximumAsyncRequests según su carga de trabajo. Equilibre el recuento de conexiones: muy pocas causan bloqueos, demasiadas sobrecargan el servidor.
• SDK de Python: Utilice la sentencia with para gestionar el ciclo de vida de la Session y garantizar la limpieza correcta de recursos.
• Elija el método adecuado: Use llamadas asíncronas para aplicaciones asíncronas (asyncio, FastAPI). Use llamadas síncronas para aplicaciones síncronas tradicionales.

Códigos de error

Si una llamada al modelo falla, consulte Mensajes de error para resolver el problema.