DEV Community

Dushyant Singh
Dushyant Singh

Posted on • Originally published at Medium

Building a Reliable TURN Server on Azure for Scalable WebRTC Applications

#webrtc #azure #cloudcomputing #tutorial

WebRTC

Introduction

In today's fast-paced digital world, real-time communication technologies like WebRTC (Web Real-Time Communication) are at the heart of many applications, from video conferencing to online gaming. While WebRTC simplifies peer-to-peer data exchange, it often faces connectivity challenges in complex network environments, such as those involving Network Address Translation (NAT) or firewalls. These challenges can lead to failed connections, especially in multi-user applications, impacting user experience and scalability.

This is where TURN (Traversal Using Relays around NAT) servers play a critical role. Unlike STUN servers, which assist in direct peer-to-peer connectivity, TURN servers relay data when direct connections fail. They ensure seamless connectivity, even in restrictive networks.

In this blog, I'll guide you through building a reliable TURN server using Coturn, a robust open-source implementation, deployed on an Azure Virtual Machine (VM). Whether you're looking to improve your WebRTC application's reliability or scale it for multi-user interactions, this comprehensive guide will help you overcome connectivity challenges and achieve robust performance.

Challenges with WebRTC Connectivity

WebRTC is a powerful technology that enables real-time audio, video, and data communication between devices. However, achieving seamless peer-to-peer connectivity is not always straightforward, especially in complex network conditions.

1. ICE Protocol Failures

Interactive Connectivity Establishment (ICE) is the backbone of WebRTC, responsible for establishing connections between peers. However, in restrictive environments involving NAT (Network Address Translation) or firewalls, ICE protocol failures are common.

  • Impact: Users experience dropped calls, failed connections, or unresponsive sessions, especially in networks blocking UDP traffic or when direct peer-to-peer connections aren't possible.

2. Scalability Issues

As WebRTC applications scale to handle multiple simultaneous users, the reliance on static STUN/TURN configurations becomes a bottleneck.

  • Impact: Using the same ICE configuration for multiple connections often leads to conflicts, disrupting ongoing sessions and affecting the overall application stability.

3. Security Concerns

Publicly exposed ICE server credentials and configurations pose significant security risks.

  • Impact: Unauthorized users may exploit these credentials, leading to data breaches or misuse of server resources.

4. Multi-User Session Conflicts

In scenarios where multiple browser tabs or devices attempt to connect simultaneously, interference between sessions can degrade performance.

  • Impact: Users face unreliable connections, making multi-user applications challenging to scale.

Why TURN Servers are the Solution

TURN servers act as relays for data, bypassing network restrictions when direct connections fail. By routing media through a centralized server, TURN ensures reliable connectivity even in challenging environments. When paired with a robust deployment like Azure and open-source solutions such as Coturn, these challenges can be effectively mitigated.

Why Use Coturn on Azure?

To address the challenges of WebRTC scalability and reliability, Coturn, an open-source TURN server, becomes an essential tool. When paired with the flexibility and scalability of Microsoft Azure, this solution provides a robust and scalable way to overcome connectivity barriers.

Key Features of Coturn:

  • Dynamic Credential Management: Supports long-term and REST-based credentials for secure user authentication, reducing conflicts in multi-user environments.
  • Customizability: Offers extensive configuration options, supporting advanced features such as TLS encryption and load balancing.
  • Cost-Effectiveness: Being open-source, Coturn removes the need for costly commercial TURN servers, making it ideal for projects with budget constraints.

Benefits of Azure:

  1. Global Reach: Azure's vast network of data centers ensures low-latency connections for users worldwide.
  2. Scalability and Flexibility: Azure virtual machines (VMs) can scale vertically or horizontally based on your application's traffic requirements.
  3. Security and Compliance: Azure includes features like firewalls, virtual networks, and compliance certifications, ensuring a secure hosting environment for your TURN server.
  4. Ease of Management: The Azure portal simplifies VM creation, monitoring, and configuration, streamlining the deployment process.

The Coturn + Azure Advantage

By deploying Coturn on Azure, you achieve a cost-effective, scalable, and secure solution for handling WebRTC connectivity challenges. This combination allows you to address current issues while preparing for future scalability needs, ensuring your WebRTC applications provide a seamless user experience.

Step-by-Step Guide: Setting Up Coturn on Azure

Step 1: Setting Up an Azure Virtual Machine (VM)

1.1 Create the Virtual Machine

  1. Log in to the Azure Portal.
  2. Navigate to Virtual Machines and click + Create.
  3. Configure the VM with the following details:
    • Resource Group: Select an existing group or create a new one.
    • VM Name: Example: CoturnServer.
    • Region: Choose a region near your users (e.g., Central India).
    • Image: Select Ubuntu Server 20.04 LTS.
    • Size: Use Standard B1s (sufficient for basic TURN server usage).
    • Authentication: Choose SSH Key or Password.

1.2 Configure Networking

  • Ensure a Public IP is assigned.
  • Open the necessary ports:
    • 3478 for TURN.
    • 5349 for TURN over TLS.
    • Ports 10000-20000 for relayed traffic.

1.3 Launch the VM

  • Click Review + Create, then Create.
  • Once deployed, connect to the VM using SSH: 
ssh <username>@<public_ip>
Enter fullscreen mode Exit fullscreen mode

Step 2: Installing Coturn

2.1 Update the System

sudo apt update
sudo apt upgrade -y
Enter fullscreen mode Exit fullscreen mode

2.2 Install Coturn

sudo apt install coturn -y
Enter fullscreen mode Exit fullscreen mode

2.3 Enable Coturn

Uncomment the following line in the configuration file to enable Coturn:

sudo nano /etc/default/coturn
Enter fullscreen mode Exit fullscreen mode

Uncomment this line:

TURNSERVER_ENABLED=1
Enter fullscreen mode Exit fullscreen mode

Save and exit by pressing CTRL + X, then Y, and Enter.

Step 3: Configuring Coturn

3.1 Backup the Default Configuration File

sudo mv /etc/turnserver.conf /etc/turnserver.conf.bak
Enter fullscreen mode Exit fullscreen mode

3.2 Create a New Configuration File

sudo nano /etc/turnserver.conf
Enter fullscreen mode Exit fullscreen mode

Add the following configuration:

# Listening ports
listening-port=3478
tls-listening-port=5349

# External IP of your Azure VM
external-ip=<your-public-ip>

# Enable long-term credentials
lt-cred-mech

# Define a user for testing
user=turnuser:securepassword

# Realm (use your domain or VM's public IP)
realm=example.com

# Enable verbose logging for debugging
verbose
log-file=/var/log/turnserver.log
Enter fullscreen mode Exit fullscreen mode

Replace <your-public-ip> and example.com with your VM's public IP and domain. Save and exit by pressing CTRL + X, then Y, and Enter.

Step 4: Testing the TURN Server

4.1 Start Coturn

sudo systemctl start coturn
sudo systemctl enable coturn
Enter fullscreen mode Exit fullscreen mode

4.2 Check the Logs

sudo journalctl -u coturn
Enter fullscreen mode Exit fullscreen mode

4.3 Test Connectivity

  1. Open the Trickle ICE tool in your browser.
  2. Add your TURN server details:
    • URL: turn:<your-public-ip>:3478.
    • Username: turnuser.
    • Password: securepassword.
  3. Click Gather Candidates to test connectivity.

Step 5: Secure and Optimize

5.1 Rotate Logs

sudo nano /etc/logrotate.d/coturn
Enter fullscreen mode Exit fullscreen mode

Add this configuration:

/var/log/turnserver/*.log {
    rotate 7
    daily
    missingok
    notifempty
    compress
    postrotate
        /bin/systemctl kill -s HUP coturn.service
    endscript
}
Enter fullscreen mode Exit fullscreen mode

5.2 Add SSL for TURN over TLS

sudo apt install certbot
sudo certbot certonly --standalone -d <your-domain>
Enter fullscreen mode Exit fullscreen mode

Update turnserver.conf to include:

cert=/etc/letsencrypt/live/<your-domain>/cert.pem
pkey=/etc/letsencrypt/live/<your-domain>/privkey.pem
tls-listening-port=443
Enter fullscreen mode Exit fullscreen mode

Step 6: Integrating the TURN Server into Your WebRTC Application

Modify the ICE configuration in your WebRTC application to include the TURN server. Below is an example code snippet in JavaScript:

// Define ICE server configuration
const iceServers = [
  {
    urls: 'stun:stun.l.google.com:19302' // Public STUN server
  },
  {
    urls: 'turn:<your-public-ip>:3478',
    username: 'turnuser',
    credential: 'securepassword'
  }
];

// Create a new peer connection using the ICE configuration
const peerConnection = new RTCPeerConnection({ iceServers });

// Add event listener to monitor connection states
peerConnection.oniceconnectionstatechange = () => {
  console.log(`ICE Connection State: ${peerConnection.iceConnectionState}`);
};

// Example of adding media tracks to the connection
navigator.mediaDevices.getUserMedia({ video: true, audio: true })
  .then(stream => {
    stream.getTracks().forEach(track => {
      peerConnection.addTrack(track, stream);
    });
  })
  .catch(error => {
    console.error('Error accessing media devices:', error);
  });
Enter fullscreen mode Exit fullscreen mode

Replace <your-public-ip> with the public IP of your Azure VM. Ensure the username and credential match the ones set in your turnserver.conf.

Conclusion

Building a reliable TURN server on Azure using Coturn is a practical and cost-effective solution for overcoming WebRTC connectivity challenges. This setup ensures that real-time applications can handle restrictive network conditions, provide seamless multi-user interactions, and scale efficiently with growing demands.

Key Takeaways

  • Addressing Connectivity Issues: By using a TURN server, you can bypass NAT and firewall restrictions, ensuring uninterrupted connections.
  • Scalability and Security: Azure's infrastructure and Coturn's capabilities together offer flexibility, reliability, and enhanced security.
  • Real-World Application: Integrating the TURN server into your WebRTC application strengthens its performance and ensures a superior user experience.

By following this guide, you've set up a robust and scalable TURN server and successfully integrated it into your WebRTC application. Whether you're developing a video conferencing tool, a gaming platform, or any other real-time communication app, this setup positions your application for success.

What's Next?

If you're looking to:

  1. Optimize Further: Explore load balancing solutions or multi-region deployments to handle high-traffic scenarios.
  2. Enhance Security: Implement dynamic credential management or TURN REST APIs for a more secure production setup.

Feel free to share your experiences or ask questions in the comments! If this blog helped you, consider sharing it with your network.

Top comments (0)