Servidores TURN configurables

Visión general

  • 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, usando OpenTok.js (para clientes web), el SDK de iOS o el SDK de Android. La API de servidores TURN personalizados personalizada fue añadida en la versión 2.13.0 de estos SDKs de cliente.

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

OpenTok.js (v2.13.0+)

En options del OT.initSession() incluye un método no documentado 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 array. Establézcalo en 'all' (el predeterminado) y el cliente utilizará tanto los servidores TURN personalizados que proporciones como los servidores TURN de Vonage.

  • transportPolicy (Cadena) - Establézcalo como 'all' (por defecto) y el cliente utilizará todos los tipos de transporte ICE (como host, srflx y TURN) para establecer la conectividad multimedia. Establezca esto a 'relay' para forzar la conectividad a través de TURN siempre e ignorar todos los demás candidatos ICE candidatos.

  • customServers (Matriz) - Defina esto como una matriz de objetos que definen sus 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 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 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 para Android

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

  • Session.Builder.setCustomIceServers() - Llame a este método para añadir una lista de servidores TURN personalizados para el cliente.

  • Session.Builder.setIceRouting() - Llame a este método para añadir la limitación de la ICE para el cliente.

Además de los dos nuevos métodos, dos nuevos enums definen las opciones del servidor TURN:

  • IncludeServers - Incluye opciones para usar sólo los servidores personalizados o ambos servidores de Vonage y 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 y introducir IncludeServers.TURN como el config parámetro.

  • setIceRouting() - Pasar TransportPolicy.Relay.

El siguiente ejemplo muestra cómo configurar 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 para definir la configuración personalizada del servidor TURN para el cliente. La clase OTSessionICEConfig define la propiedad OTSessionSettings.iceConfig propiedad.

Nota: Para que el cliente sólo utilice los servidores TURN que especifiques (y no utilice los servidores TURN de Vonage), llama a la función [OTSessionSettings addICEServerWithURL:] del objeto del objeto OTSessionSettings que utiliza para crear el objeto OTSession. A continuación, establezca las siguientes propiedades del objeto OTSessionSettings:

  • includeServers - Establézcalo como OTSessionICEIncludeServersCustom.

  • transportPolicy - Establézcalo como 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 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 para Windows

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

En 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 -- Establecer este 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 -- Establecer este 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 sólo utilizará los servidores TURN personalizados que usted le proporcione.

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:

SDK 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. Llama al otc_session_settings_set_custom_ice_config() y pasar la dirección otc_custom_ice_config instancia:
otc_session_settings_set_custom_ice_config(session_settings,
                                           &ice_config);

El siguiente ejemplo muestra cómo configurar 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() y pasar la dirección otc_custom_ice_config instancia:

otc_session_settings_set_custom_ice_config(session_settings,
                                           &ice_config);

El siguiente ejemplo muestra cómo configurar 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

En options puntal del OTSession 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 array. Establézcalo 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' (por defecto) y el cliente utilizará todos los tipos de transporte ICE (como host, srflx y TURN) para establecer la conectividad multimedia. Establezca esto a 'relay' para forzar la conectividad a través de TURN siempre e ignorar todos los demás candidatos ICE candidatos.

  • customServers (Matriz) - Defina esto como una matriz de objetos que definen sus 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 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 retransmitidano podrá suscribirse a sus propios flujos (flujos que publica).

Preguntas frecuentes

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

No. TURN configurable disipa las preocupaciones de los clientes sobre la conexión a puntos finales de confianza para tráfico multimedia.

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

  • Lista blanca de nombres de dominio 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 medios entre los objetivos TURN disponibles? Se tiene en cuenta la latencia de ida y vuelta, se ve influida por el orden en el que enumeramos los objetivos 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 se asigna a múltiples direcciones IP, ¿cómo se selecciona el servidor TURN específico para la sesión? ¿Es aleatorio?

La mayoría de las implementaciones, incluidas las utilizadas en Chrome y Firefox, toman la primera IP devuelta por la búsqueda DNS. El resultado suele ser una selección aleatoria de tipo 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 distintas rutas de medios para distintos flujos?

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

¿Cuánto control tiene la API Configurable TURN en la selección de la ruta de los medios?

La selección de la ruta de los medios es manejada por ICE (Interactive Connectivity Establishment) dentro de WebRTC, y no tenemos forma de modificar este comportamiento. La API configurable de TURN sólo ayuda a modificar la lista de servidores ICE proporcionada por el cliente a WebRTC y no influye en el proceso de selección.

¿Siempre es preferible la conexión directa al servidor de medios 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?

Esto no es recomendable, ya que hará que el cliente elija un servidor al azar y ese servidor puede cambiar durante la duración de la conexión.

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

Póngase 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 utilizando DTLS-SRTP y sólo 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 recuperarlo?

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.