Servidores TURN configurables

Puedes configurar los servidores TURN que utiliza un cliente de OpenTok.

Esta función está disponible como funcionalidad adicional.

Este tema incluye las siguientes secciones:

• Visión general
• OpenTok.js
• SDK de OpenTok para Android
• SDK de OpenTok para iOS
• SDK de OpenTok para Windows
• SDK de OpenTok para macOS
• SDK de OpenTok para Linux
• SDK React Native de OpenTok
• Problema conocido
• Preguntas frecuentes

Visión general

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 utilizar exclusivamente tus servidores TURN o si debe utilizarlos además de los servidores TURN de OpenTok

Añadir tus propios servidores TURN puede ayudar a los usuarios a conectarse en entornos de red restrictivos en los que los servidores TURN de OpenTok podrían estar bloqueados.

Si decides anular los servidores TURN de OpenTok y utilizar únicamente tus propios servidores TURN, puedes asegurarte de que los flujos multimedia 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 OpenTok para iOS o el SDK de OpenTok para Android. La API del servidor TURN personalizado se incorporó en la versión 2.13.0 de estos Client SDK para clientes.

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 las llamadas a la Video API, las conexiones WebSocket y el tráfico de registros—.

OpenTok.js

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' (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.

Para actualizar dinámicamente las credenciales personalizadas de TURN, utiliza el 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 OpenTok para 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 de 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 OpenTok como los servidores personalizados.

• TransportPolicy — Describe el método de enrutamiento que se debe utilizar.

Nota: Para que el cliente utilice únicamente los servidores TURN que especifiques (y no los servidores TURN de OpenTok), invoca los siguientes métodos del objeto Session.Builder que utilices para crear el objeto Session:

• setCustomIceServers() — Pasa una lista de objetos IceServer (que correspondan a tus servidores TURN personalizados) como el serverList parámetro, y pasarlo IncludeServers.TURN como el config parámetro.

• setIceRouting() — Pasa el balón 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 de OpenTok 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 OpenTok), 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 = OTSessionICETransportRelay;

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 OpenTok para 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 OpenTok, además de los servidores TURN personalizados que usted proporcione.

  • Custom -- El cliente solo utilizará los servidores TURN personalizados que le facilites.

La clase Session.Builder incluye un IceConfig propiedad. Asigna a esta un objeto IceConfig al crear el objeto Session.

El siguiente ejemplo muestra cómo configurar los 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, apiKey, sessionId){
  IceConfig = iceConfig
}.Build();

SDK de OpenTok para 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.

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 OpenTok session successfully");
  return EXIT_FAILURE;
}

otc_session_connect(session, TOKEN);

SDK de OpenTok 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 OpenTok session successfully");
  return EXIT_FAILURE;
}

otc_session_connect(session, TOKEN);

SDK React Native de OpenTok

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
  apiKey="your-api-key"
  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 los nombres de dominio de OpenTok a la lista blanca:

  • *.opentok.com
  • *.tokbox.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 OpenTok trata cada flujo multimedia 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 OpenTok a través de UDP?

Sí, siempre es preferible la conexión directa al servidor multimedia de OpenTok. Se recurre al uso de TURN si la conexión al servidor multimedia de OpenTok no se establece correctamente o si se utiliza la opción «Forzar TURN» en la API TURN configurable.

¿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?

Puedes probar tu servidor TURN utilizando el Entorno de pruebas de la Video API, el Página de prueba de Trickle Ice o el coturn turnutils_uclient.