Servidores TURN configurables

Visión general

Esta función está disponible como funcionalidad adicional.

Client SDK: Tenga en cuenta que su ID de la aplicación ¿Es tu Clave API.

Puede personalizar el uso del servidor TURN para cada cliente de la sesión de las siguientes formas:

Puedes añadir una lista de tus propios servidores TURN que utilizará el cliente.
Puedes decidir si el cliente debe usar tus servidores TURN exclusivamente o usarlos además de los servidores TURN de Vonage

Agregar tus propios servidores TURN puede ayudar a los usuarios a conectarse en entornos de red restrictivos donde los servidores TURN de Vonage pueden estar bloqueados.

Si decides anular los servidores TURN de Vonage y utilizar sólo tus propios servidores TURN, puedes asegurarte de que los flujos de medios nunca salgan de tu red.

Puedes añadir tus propios servidores TURN para cada cliente que se conecte a la sesión, utilizando OpenTok.js (para clientes web), el SDK de iOS o el SDK de Android. La API del servidor TURN personalizado se incorporó en la versión 2.13.0 de estos Client SDK.

También hay un Proxy IP que le permite utilizar su propio servidor proxy para enrutar no relacionado con los medios de comunicación tráfico, como llamadas a la Video API, conexiones WebSocket y tráfico de registro.

OpenTok.js (v2.13.0+)

El options del OT.initSession() El método incluye un iceConfig propiedad. Esta propiedad incluye las siguientes propiedades:

includeServers (Cadena) - Establézcalo como 'custom' y el cliente sólo utilizarán los TURN personalizados que proporcione en el customServers matriz. Establece este valor en 'all' (la opción predeterminada) y el cliente utilizará tanto los servidores TURN personalizados que facilites como los servidores TURN de Vonage.
transportPolicy (Cadena) - Establézcalo como 'all' (el valor predeterminado) y el cliente utilizará todos los tipos de transporte ICE (como host, srflx y TURN) para establecer la conectividad multimedia. Configúralo en 'relay' para forzar la conectividad a través de TURN siempre e ignorar todos los demás candidatos ICE candidatos.
customServers (Matriz) - Establece este parámetro como una matriz de objetos que definan tus servidores TURN personalizados. Cada objeto corresponde a un servidor TURN personalizado e incluye las siguientes propiedades:
- urls (Cadena o matriz de cadenas) - Una cadena o una matriz de cadenas, donde cada cadena es una URL soportada por el servidor TURN (y sólo puede ser una URL).
- username (Cadena) - El nombre de usuario para el servidor TURN definido en este objeto.
- credential (Cadena) - La cadena de credenciales del servidor TURN definido en este objeto.

Nota: Para que el cliente sólo use los servidores TURN que especifiques (y no use los servidores TURN de Vonage): configura la opción includeServers propiedad a 'custom', fije el transportPolicy propiedad a 'relay'y ajuste el customServers para listar sus servidores servidores TURN.

Para actualizar las credenciales TURN personalizadas de forma dinámica, utilice el comando Session.setIceConfig() método.

El siguiente ejemplo muestra cómo configurar los servidores TURN para el cliente:

const session = OT.initSession(projectId, sessionId, {
  iceConfig: {
    includeServers: 'custom',
    transportPolicy: 'relay',
    customServers: [
      {
        urls: [
          'turn:123.124.125.126:3478?transport=udp',
          'turn:123.124.125.126:3478?transport=tcp'
        ],
        username: 'webrtc',
        credential: 'foO0Bar1'
      },
      {
          urls: [
            'turns:turntls.example.com:3478?transport=tcp'
          ],
          username: 'webrtc',
          credential: 'foO0Bar2',
      },
    ],
  },
});

SDK de Android

El Session.Builder incluye dos métodos para configurar el uso del servidor TURN para el cliente:

Session.Builder.setCustomIceServers() - Llama a este método para añadir una lista de servidores TURN personalizados para el cliente.
Session.Builder.setIceRouting() - Llama a este método para añadir opciones de limitación del ICE para el cliente.

Además de los dos nuevos métodos, hay dos nuevas enumeraciones que definen las opciones del servidor TURN:

IncludeServers - Incluye opciones para utilizar únicamente los servidores personalizados o tanto los servidores de Vonage como los servidores personalizados.
TransportPolicy - Describe el método de enrutamiento a utilizar.

Nota: Para que el cliente sólo utilice los servidores TURN que especifiques (y no utilice los servidores TURN de Vonage), llama a los siguientes métodos del objeto Session.Builder que utilizas para crear el objeto Session:

setCustomIceServers() - Introduzca una lista de objetos IceServer (correspondientes a sus servidores TURN personalizados) como el objeto serverList parámetro, y pasarlo IncludeServers.TURN como el config parámetro.
setIceRouting() - Pasar TransportPolicy.Relay.

El siguiente ejemplo muestra cómo configurar los servidores TURN para el cliente:

List<IceServer> serverList = new IceServer(
  'turn:123.124.125.126:3478?transport=udp', // TURN server URL
  'webrtc', // Username
  'foO0Bar1' // Credential
);
mSession = new Session.Builder(this, apiKey, sessionId)
  .setCustomIceServers(serverList, IncludeServers.Custom)
  .setIceRouting(TransportPolicy.TURN)
  .build();
mSession.setSessionListener(this);
mSession.connect(token);

SDK para iOS

Al inicializar un objeto OTSession, establezca el parámetro OTSessionSettings.iceConfig propiedad para definir la configuración personalizada del servidor TURN para el cliente. La clase OTSessionICEConfig define la OTSessionSettings.iceConfig propiedad.

Nota: Para que el cliente utilice únicamente los servidores TURN que especifiques (y no los servidores TURN de Vonage), llama a la función [OTSessionSettings addICEServerWithURL:] método de el objeto OTSessionSettings que utilizas para crear el objeto OTSession. A continuación, configura las siguientes propiedades del objeto OTSessionSettings:

includeServers - Establece este valor en «OTSessionICEIncludeServersCustom».
transportPolicy - Establece este valor en OTSessionICETransportRelay.

Puede ajustar el OTSessionICEConfig.filterOutLanCandidates para evitar suscribirse a clientes en la misma red local en sesiones retransmitidas, lo que hace que la aplicación pida permiso al usuario en iOS 14+. Tenga en cuenta que esta función no requieren el complemento configurable TURN. Para más información, consulte este tema.

El siguiente ejemplo muestra cómo configurar los servidores TURN para el cliente:

OTSessionICEConfig *myICEServerConfiguration = [[OTSessionICEConfig alloc] init];
myICEServerConfiguration.includeServers = OTSessionICEIncludeServersCustom;
myICEServerConfiguration.transportPolicy = OTSessionICETransportForceTurn

NSError *error = nil;
[myICEServerConfiguration addICEServerWithURL:@"turn:123.124.125.126:3478?transport=udp"
                                     userName:@"webrtc"
                                   credential:@"foO0Bar1"
                                        error:&error];

OTSessionSettings *settings = [[OTSessionSettings alloc] init];
settings.iceConfig = myICEServerConfiguration;

_session = [[OTSession alloc] initWithApiKey:kApiKey
                                   sessionId:kSessionId
                                    delegate:self
                                    settings:settings];

SDK de Windows

Utiliza la clase IceConfig para establecer la configuración ICE personalizada que utilizará el cliente.

El IceConfig() incluye los siguientes parámetros:

customIceServers -- Establecer esto como Una lista de objetos IceServer, que representan servidores TURN personalizados que utilizará el cliente. Para cada IceServer, se establece la URL, el nombre de usuario y la cadena de credenciales para el servidor TURN personalizado
transportPolicy -- Establece esto en un valor en el ICETransport enum:
- All -- El cliente utilizará todos los tipos de candidatos ICE (como host, srflx y relay) para establecer la conectividad de medios.
- Relayed -- El cliente forzará la conectividad a través de TURN siempre e ignorará todos los demás candidatos ICE.
includeServers -- Establece esto en un valor en el IncludeServers enum:
- All -- El cliente utilizará los servidores TURN de Vonage además de los los servidores TURN personalizados que proporciones.
- Custom -- El cliente solo utilizará los servidores TURN personalizados que le facilites.

La clase Session.Builder incluye un IceConfig propiedad. Establezca esta propiedad a un objeto IceConfig cuando se construye el objeto Session. El siguiente ejemplo muestra cómo configurar servidores TURN para el cliente:

List<IceServer> iceServers = new List<IceServer>() {
  new IceServer(
    "turn:123.124.125.126:3478?transport=udp", "webrtc", "fo0Bar1"
  )
};
IceConfig iceConfig = new IceConfig(
  iceServers,
  ICETransport.Relayed,
  ICEIncludeServers.Custom
);
session = new Session.Builder(context, applicationId, sessionId){
  IceConfig = iceConfig
}.Build();

SDK de macOS

El tipo otc_custom_ice_config define una estructura que incluye los siguientes miembros:

num_ice_servers -- El número de servidores ICE
ice_url -- Una matriz de cadenas que especifica las URL de su servidor ICE.
ice_user -- Una matriz de cadenas que especifica los nombres de usuario para los servidores TURN.
ice_credential -- Una matriz de cadenas que especifica las cadenas de credenciales para los servidores TURN. Llama a la función otc_session_settings_set_custom_ice_config() función y pasarle el otc_custom_ice_config instancia:

otc_session_settings_set_custom_ice_config(session_settings,
                                           &ice_config);

El siguiente ejemplo muestra cómo configurar los servidores TURN para el cliente:

// Provide the ICE configuration here.
struct otc_custom_ice_config ice_config;
ice_config.num_ice_servers = 1;
ice_config.ice_url = (char **)malloc(sizeof(char *) * ice_config.num_ice_servers);
ice_config.ice_url[0] = strdup("turn:123.124.125.126:3478?transport=udp");
ice_config.ice_user = (char **)malloc(sizeof(char *) * ice_config.num_ice_servers);
ice_config.ice_user[0] = strdup("webrtc");
ice_config.ice_credential = (char **)malloc(sizeof(char *) * ice_config.num_ice_servers);
ice_config.ice_credential[0] = strdup("foO0Bar1");
ice_config.force_turn = OTC_TRUE;
ice_config.use_custom_turn_only = OTC_FALSE;
otc_session_settings *session_settings = otc_session_settings_new();
if (session_settings != NULL) {
  otc_session_settings_set_custom_ice_config(session_settings,
                                             &ice_config);
}
otc_session *session = NULL;
session = otc_session_new_with_settings(API_KEY,
                                        SESSION_ID,
                                        &session_callbacks,
                                        session_settings);
if (session == NULL) {
  printf("Could not create session successfully");
  return EXIT_FAILURE;
}
otc_session_connect(session, TOKEN);

SDK para Linux

El tipo otc_custom_ice_config define una estructura que incluye los siguientes miembros:

num_ice_servers -- El número de servidores ICE
ice_url -- Una matriz de cadenas que especifica las URL de su servidor ICE.
ice_user -- Una matriz de cadenas que especifica los nombres de usuario para los servidores TURN.
ice_credential -- Una matriz de cadenas que especifica las cadenas de credenciales para los servidores TURN.

Llame al otc_session_settings_set_custom_ice_config() función y pasarle el otc_custom_ice_config instancia:

otc_session_settings_set_custom_ice_config(session_settings,
                                           &ice_config);

El siguiente ejemplo muestra cómo configurar los servidores TURN para el cliente:

// Provide the ICE configuration here.
struct otc_custom_ice_config ice_config;
ice_config.num_ice_servers = 1;
ice_config.ice_url = (char **)malloc(sizeof(char *) * ice_config.num_ice_servers);
ice_config.ice_url[0] = strdup("turn:123.124.125.126:3478?transport=udp");
ice_config.ice_user = (char **)malloc(sizeof(char *) * ice_config.num_ice_servers);
ice_config.ice_user[0] = strdup("webrtc");
ice_config.ice_credential = (char **)malloc(sizeof(char *) * ice_config.num_ice_servers);
ice_config.ice_credential[0] = strdup("foO0Bar1");
ice_config.force_turn = OTC_TRUE;
ice_config.use_custom_turn_only = OTC_FALSE;

otc_session_settings *session_settings = otc_session_settings_new();
if (session_settings != NULL) {
  otc_session_settings_set_custom_ice_config(session_settings,
                                             &ice_config);
}

otc_session *session = NULL;

session = otc_session_new_with_settings(API_KEY,
                                        SESSION_ID,
                                        &session_callbacks,
                                        session_settings);

if (session == NULL) {
  printf("Could not create session successfully");
  return EXIT_FAILURE;
}

otc_session_connect(session, TOKEN);

SDK de React Native

El options puntal del OTSession Este componente incluye un iceConfig propiedad. Este objeto incluye las siguientes propiedades:

includeServers (Cadena) - Establézcalo como 'custom' y el cliente sólo utilizarán los TURN personalizados que proporcione en el customServers matriz. Establece este valor en 'all' (por defecto) y el cliente utilizará tanto los servidores TURN personalizados que proporciones como los servidores TURN de OpenTok.
transportPolicy (Cadena) - Establézcalo como 'all' (el valor predeterminado) y el cliente utilizará todos los tipos de transporte ICE (como host, srflx y TURN) para establecer la conectividad multimedia. Configúralo en 'relay' para forzar la conectividad a través de TURN siempre e ignorar todos los demás candidatos ICE candidatos.
customServers (Matriz) — Establece este parámetro como una matriz de objetos que definan tus servidores TURN personalizados. Cada objeto corresponde a un servidor TURN personalizado e incluye las siguientes propiedades:
- urls (Cadena o matriz de cadenas) - Una cadena o una matriz de cadenas, donde cada cadena es una URL soportada por el servidor TURN (y sólo puede ser una URL).
- username (Cadena) - El nombre de usuario para el servidor TURN definido en este objeto.
- credential (Cadena) - La cadena de credenciales para el servidor TURN definido en este objeto.

Nota: Para que el cliente sólo utilice los servidores TURN que especifiques (y no utilice los servidores TURN de OpenTok): establece la opción includeServers propiedad a 'custom', fije el transportPolicy propiedad a 'relay'y ajuste el customServers para listar sus servidores servidores TURN.

El siguiente ejemplo muestra cómo configurar los servidores TURN para el cliente:

<OTSession
  applicationId="your-application-id"
  sessionId="your-session-id"
  token="your-session-token"
  options={{
    iceConfig:{
      transportPolicy: 'all',
      includeServers: 'all',
      customServers: [
        {
        urls: [
          'turn:123.124.125.126:3478?transport=udp',
          'turn:123.124.125.126:3478?transport=tcp'
        ],
        username: 'webrtc',
        credential: 'foO0Bar1'
        },
      ],
    }
  }}
>
  <OTPublisher style={{ width: 600, height: 400 }}/>
  <OTSubscriber style={{ width: 600, height: 400 }} />
</OTSession>

Problema conocido

Si configura un cliente para que utilice siempre servidores TURN en un sesión retransmitida, no podrá suscribirse a sus propias transmisiones (las que publica).

Preguntas frecuentes

¿Resuelve la API TURN configurable el problema del tráfico HTTP?

No. TURN configurable disipa las dudas de los clientes en cuanto a la conexión a puntos finales de confianza únicamente para el tráfico multimedia.

Para el tráfico HTTP, los clientes tendrán que hacer una de las siguientes cosas:

Añadir a la lista blanca los nombres de dominio de Vonage y Opentok:
- *.opentok.com
- *.tokbox.com
- *.vonage.com
Bloques de direcciones IP de lista blanca provistos para la Video API de Vonage.
Usa la configuración de proxy web en los clientes para proxy todo el tráfico HTTPS de Vonage a través de sus propios objetivos. Consulta la sección Requisitos del proxy aquí.

¿Cómo se selecciona la ruta de transmisión entre los destinos TURN disponibles? ¿Se tiene en cuenta la latencia de ida y vuelta, o depende del orden en que enumeramos los destinos, o es aleatoria?

El orden de los servidores TURN no está garantizado en base a la lista proporcionada. En su lugar, cuando los medios comienzan la implementación ICE selecciona qué candidato/servidor tiene la mejor conectividad y ha negociado con éxito primero. negociado primero.

Si la URL del servidor TURN apunta a varias direcciones IP, ¿cómo se selecciona el servidor TURN concreto para la sesión? ¿Se hace al azar?

La mayoría de las implementaciones, incluidas las que se utilizan en Chrome y Firefox, toman la primera dirección IP devuelta por la consulta DNS. Esto suele dar lugar a una selección aleatoria por el método «round-robin».

Si se dispone de servidores TURN tanto TCP como UDP y son accesibles, ¿es posible dar prioridad a los objetivos UDP y sólo recurrir a TCP en caso necesario?

Los candidatos a retransmisión UDP tendrán preferencia sobre los candidatos a retransmisión TCP, ya que estos candidatos tienen una preferencia de tipo local más baja y, por lo tanto, una prioridad más baja. menor preferencia de tipo local y, por tanto, una prioridad menor. Consulte RFC 8445 para más detalles. El orden de los servidores ICE introducidos no influye.

¿Puede un mismo cliente utilizar diferentes rutas multimedia para diferentes transmisiones?

Sí, este es el comportamiento esperado ya que Vonage trata cada flujo de medios individual por separado.

¿Qué grado de control tiene la API TURN configurable sobre la selección de la ruta de transmisión?

La selección de la ruta de transmisión la gestiona ICE (Interactive Connectivity Establishment) dentro de WebRTC, y no tenemos forma de modificar este comportamiento. La API Configurable TURN solo permite modificar la lista de servidores ICE que el cliente proporciona a WebRTC y no influye en el proceso de selección.

¿Es siempre preferible la conexión directa al servidor multimedia de Vonage a través de UDP?

Sí, siempre es preferible la conexión directa al servidor de medios de Vonage. Se pasa al uso de TURN si la conexión con el servidor de medios de Vonage no tiene éxito o si se utiliza la opción "Forzar TURN en la API configurable de TURN.

¿Puedo utilizar varios servidores TURN del mismo tipo para equilibrar la carga?

No se recomienda esta opción, ya que el cliente seleccionará un servidor al azar y dicho servidor podría cambiar durante el tiempo que dure la conexión.

¿Cómo puedo equilibrar la carga de mi servidor TURN personalizado?

Ponte en contacto con nosotros para obtener más información.

¿Puede el servidor TURN desencriptar medios?

No, el servidor TURN no tiene acceso a las claves SRTP que se intercambian mediante DTLS-SRTP y que solo están disponibles para los extremos de la conexión.

¿Qué ocurre si un servidor TURN se bloquea durante una sesión y cómo se puede solucionar?

Si un servidor TURN se bloquea mientras se está utilizando, la conexión del cliente se desconectará. El cliente intentará restablecer la conexión mediante un reinicio ICE.

¿Cómo puedo probar un servidor TURN?

Puede probar su servidor TURN utilizando Página de prueba de Trickle Ice o coturn turnutils_uclient.