Voice Chat Server Setup on Alpine Linux

Setting up your own voice chat server provides complete control over your communication platform, better privacy, and customization options. Let’s explore how to set up different voice chat solutions on Alpine Linux! 🗣️

Voice Chat Server Options

We’ll cover three popular options:

1. Mumble (Murmur): Open-source, low-latency voice chat
2. TeamSpeak 3: Popular gaming voice communication
3. Discord Bot: Automated Discord functionality

Prerequisites

Before starting, ensure you have:

• Alpine Linux system with root access
• Sufficient bandwidth for voice traffic
• Open firewall ports for voice services
• Domain name (optional but recommended)

Option 1: Setting Up Mumble Server (Murmur)

Mumble is an excellent open-source voice chat solution with low latency and high quality audio.

Step 1: Install Mumble Server

# Update package repositories
sudo apk update

# Install Mumble server (Murmur)
sudo apk add murmur

# Install additional dependencies
sudo apk add openssl ca-certificates

Step 2: Configure Mumble Server

# Create mumble user for security
sudo adduser -D -s /bin/false mumble

# Edit Mumble configuration
sudo nano /etc/murmur.ini

Configure the Mumble server:

# Basic Configuration
database=/var/lib/mumble-server/mumble-server.sqlite
ice="tcp -h 127.0.0.1 -p 6502"
autobanAttempts=10
autobanTimeframe=120
autobanTime=300

# Network Settings
port=64738
host=0.0.0.0
bandwidth=72000

# Security Settings
serverpassword=YourServerPassword
welcometext="Welcome to our Mumble server!"

# SSL Configuration
sslCert=/etc/murmur/server.crt
sslKey=/etc/murmur/server.key

# Logging
logfile=/var/log/mumble-server/mumble-server.log
loglevel=1

# User Limits
users=100
channelnestinglimit=10
channelcountlimit=1000

# Text Message Settings
textmessagelength=5000
imagemessagelength=131072

# Recording Settings
allowhtml=true
opusthreshold=100

Step 3: Generate SSL Certificates

# Create certificate directory
sudo mkdir -p /etc/murmur

# Generate SSL certificate
sudo openssl req -new -x509 -keyout /etc/murmur/server.key \
    -out /etc/murmur/server.crt -days 365 -nodes \
    -subj "/C=US/ST=State/L=City/O=Organization/CN=your-domain.com"

# Set proper permissions
sudo chown -R mumble:mumble /etc/murmur
sudo chmod 600 /etc/murmur/server.key
sudo chmod 644 /etc/murmur/server.crt

Step 4: Create Systemd Service

# Create service file
sudo nano /etc/init.d/murmur

Add service script:

#!/sbin/openrc-run

name="murmur"
description="Mumble Server (Murmur)"

command="/usr/bin/murmurd"
command_args="-ini /etc/murmur.ini"
command_user="mumble:mumble"
pidfile="/var/run/mumble-server/mumble-server.pid"

depend() {
    need net
    after firewall
}

start_pre() {
    checkpath --directory --owner mumble:mumble --mode 0755 \
        /var/run/mumble-server \
        /var/lib/mumble-server \
        /var/log/mumble-server
}

Step 5: Start and Enable Mumble

# Make service executable
sudo chmod +x /etc/init.d/murmur

# Start Mumble server
sudo rc-service murmur start

# Enable on boot
sudo rc-update add murmur default

# Check status
sudo rc-service murmur status

Step 6: Set SuperUser Password

# Set superuser password
sudo -u mumble murmurd -ini /etc/murmur.ini -supw YourSuperUserPassword

Option 2: Setting Up TeamSpeak 3 Server

TeamSpeak 3 is popular for gaming communities and offers excellent voice quality.

Step 1: Download TeamSpeak 3 Server

# Create teamspeak user
sudo adduser -D -s /bin/false teamspeak

# Switch to teamspeak user
sudo su - teamspeak -s /bin/sh

# Create installation directory
mkdir -p /home/teamspeak/teamspeak3

# Download TeamSpeak 3 Server
cd /home/teamspeak
wget https://files.teamspeak-services.com/releases/server/3.13.7/teamspeak3-server_linux_amd64-3.13.7.tar.bz2

# Extract the archive
tar -xjf teamspeak3-server_linux_amd64-3.13.7.tar.bz2
mv teamspeak3-server_linux_amd64/* teamspeak3/

Step 2: Configure TeamSpeak 3

# Create configuration file
cd /home/teamspeak/teamspeak3
nano ts3server.ini

Add TeamSpeak configuration:

# Server Configuration
machine_id=
default_voice_port=9987
voice_ip=0.0.0.0
licensepath=
filetransfer_port=30033
filetransfer_ip=0.0.0.0
query_port=10011
query_ip=0.0.0.0

# Database Configuration
dbplugin=ts3db_sqlite3
dbpluginparameter=
dbsqlpath=sql/
dbsqlcreatepath=create_sqlite/
dbconnections=10

# Logging
logpath=logs
logquerycommands=0
dbclientkeepdays=30
logappend=0
query_skipbruteforcecheck=0

Step 3: Accept License and Start Server

# Accept license
touch .ts3server_license_accepted

# Start TeamSpeak server
./ts3server_startscript.sh start

# Get server admin token (save this!)
cat logs/ts3server_*.log | grep -i token

Step 4: Create TeamSpeak Service

# Exit teamspeak user
exit

# Create service file
sudo nano /etc/init.d/teamspeak3

Add service script:

#!/sbin/openrc-run

name="teamspeak3"
description="TeamSpeak 3 Server"

user="teamspeak"
group="teamspeak"
command="/home/teamspeak/teamspeak3/ts3server_startscript.sh"
command_args="start"
pidfile="/var/run/teamspeak3.pid"

depend() {
    need net
    after firewall
}

start() {
    ebegin "Starting TeamSpeak 3 Server"
    start-stop-daemon --start --user $user --group $group \
        --chdir /home/teamspeak/teamspeak3 \
        --exec $command -- $command_args
    eend $?
}

stop() {
    ebegin "Stopping TeamSpeak 3 Server"
    start-stop-daemon --stop --user $user \
        --chdir /home/teamspeak/teamspeak3 \
        --exec $command -- stop
    eend $?
}

Step 5: Enable TeamSpeak Service

# Make service executable
sudo chmod +x /etc/init.d/teamspeak3

# Start service
sudo rc-service teamspeak3 start

# Enable on boot
sudo rc-update add teamspeak3 default

Option 3: Setting Up Discord Bot

Create a Discord bot for automated server management and voice channel features.

Step 1: Install Node.js and Dependencies

# Install Node.js and npm
sudo apk add nodejs npm

# Create bot directory
mkdir -p /home/discord-bot
cd /home/discord-bot

# Initialize npm project
npm init -y

# Install Discord.js and dependencies
npm install discord.js dotenv @discordjs/voice @discordjs/opus

Step 2: Create Discord Bot

# Create main bot file
nano bot.js

Add bot code:

const { Client, GatewayIntentBits, Collection } = require('discord.js');
const { joinVoiceChannel, createAudioPlayer, createAudioResource } = require('@discordjs/voice');
require('dotenv').config();

// Create Discord client
const client = new Client({
    intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.GuildVoiceStates,
        GatewayIntentBits.MessageContent
    ]
});

// Bot ready event
client.once('ready', () => {
    console.log(`Bot is ready! Logged in as ${client.user.tag}`);
});

// Voice channel management
client.on('messageCreate', async (message) => {
    if (message.author.bot) return;

    // Join voice channel command
    if (message.content === '!join') {
        const voiceChannel = message.member.voice.channel;
        if (!voiceChannel) {
            return message.reply('You need to be in a voice channel!');
        }

        try {
            const connection = joinVoiceChannel({
                channelId: voiceChannel.id,
                guildId: message.guild.id,
                adapterCreator: message.guild.voiceAdapterCreator,
            });
            message.reply('Joined voice channel!');
        } catch (error) {
            console.error('Error joining voice channel:', error);
            message.reply('Failed to join voice channel.');
        }
    }

    // Leave voice channel command
    if (message.content === '!leave') {
        const connection = getVoiceConnection(message.guild.id);
        if (connection) {
            connection.destroy();
            message.reply('Left voice channel!');
        } else {
            message.reply('Not in a voice channel.');
        }
    }

    // Server info command
    if (message.content === '!serverinfo') {
        const embed = {
            color: 0x0099ff,
            title: 'Server Information',
            fields: [
                { name: 'Server Name', value: message.guild.name, inline: true },
                { name: 'Members', value: message.guild.memberCount.toString(), inline: true },
                { name: 'Created', value: message.guild.createdAt.toDateString(), inline: true }
            ],
            timestamp: new Date(),
        };
        message.reply({ embeds: [embed] });
    }
});

// Login with bot token
client.login(process.env.DISCORD_TOKEN);

Step 3: Configure Environment

# Create environment file
nano .env

Add your Discord bot token:

DISCORD_TOKEN=your_discord_bot_token_here

Step 4: Create Discord Bot Service

# Create service file
sudo nano /etc/init.d/discord-bot

Add service script:

#!/sbin/openrc-run

name="discord-bot"
description="Discord Bot Service"

user="nobody"
group="nobody"
command="/usr/bin/node"
command_args="/home/discord-bot/bot.js"
pidfile="/var/run/discord-bot.pid"
command_background="yes"

depend() {
    need net
}

start_pre() {
    cd /home/discord-bot
}

Firewall Configuration

Configure firewall for voice chat servers:

# Install iptables
sudo apk add iptables

# Mumble ports
sudo iptables -A INPUT -p tcp --dport 64738 -j ACCEPT
sudo iptables -A INPUT -p udp --dport 64738 -j ACCEPT

# TeamSpeak 3 ports
sudo iptables -A INPUT -p udp --dport 9987 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 30033 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 10011 -j ACCEPT

# Save iptables rules
sudo iptables-save > /etc/iptables/rules.v4

Server Administration and Management

Mumble Administration

# Connect to Mumble ICE interface
mumble-server-cli --server localhost --port 6502

# Create channels
channel_create --name "Gaming" --parent 0

# Set user permissions
user_setstate --session 1 --mute false --deaf false

TeamSpeak 3 Administration

# Connect to TeamSpeak query
telnet localhost 10011

# Login as serveradmin
login serveradmin YourPassword

# Create channel
channelcreate channel_name=Gaming

# Set server info
serveredit virtualserver_name="My TeamSpeak Server"

Monitor Voice Servers

Create monitoring script:

# Create monitoring script
sudo nano /usr/local/bin/voice-server-monitor.sh

Add monitoring logic:

#!/bin/sh

echo "=== Voice Server Status ==="
echo "Date: $(date)"
echo

# Check Mumble
if pgrep murmurd > /dev/null; then
    echo "✓ Mumble Server: Running"
    echo "  Port 64738: $(netstat -ln | grep :64738 || echo 'Not listening')"
else
    echo "✗ Mumble Server: Not running"
fi

# Check TeamSpeak
if pgrep ts3server > /dev/null; then
    echo "✓ TeamSpeak 3: Running"
    echo "  Port 9987: $(netstat -ln | grep :9987 || echo 'Not listening')"
else
    echo "✗ TeamSpeak 3: Not running"
fi

# Check Discord Bot
if pgrep -f "node.*bot.js" > /dev/null; then
    echo "✓ Discord Bot: Running"
else
    echo "✗ Discord Bot: Not running"
fi

# Check system resources
echo
echo "=== System Resources ==="
echo "Memory usage: $(free -h | grep '^Mem:' | awk '{print $3 "/" $2}')"
echo "CPU load: $(uptime | awk -F'load average:' '{print $2}')"

Security Best Practices

Secure Your Voice Servers

1. Use Strong Passwords: Set complex passwords for admin accounts
2. Enable SSL/TLS: Use encrypted connections
3. Regular Updates: Keep server software updated
4. Access Control: Limit admin access
5. Backup Configurations: Regular backup of settings

Network Security

# Fail2ban for brute force protection
sudo apk add fail2ban

# Configure fail2ban for TeamSpeak
sudo nano /etc/fail2ban/jail.local

Add fail2ban configuration:

[teamspeak3]
enabled = true
port = 10011
protocol = tcp
filter = teamspeak3
logpath = /home/teamspeak/teamspeak3/logs/ts3server_*.log
maxretry = 5
bantime = 3600

Performance Optimization

Audio Quality Settings

For Mumble, optimize audio quality:

# In /etc/murmur.ini
bandwidth=130000
opusthreshold=100

For TeamSpeak, adjust codec settings in client.

System Optimization

# Increase file descriptor limits
echo "* soft nofile 65536" >> /etc/security/limits.conf
echo "* hard nofile 65536" >> /etc/security/limits.conf

# Optimize network settings
echo "net.core.rmem_default = 262144" >> /etc/sysctl.conf
echo "net.core.rmem_max = 16777216" >> /etc/sysctl.conf
echo "net.core.wmem_default = 262144" >> /etc/sysctl.conf
echo "net.core.wmem_max = 16777216" >> /etc/sysctl.conf

# Apply changes
sysctl -p

Troubleshooting Common Issues

Connection Problems

# Check if service is running
sudo rc-service murmur status

# Check port availability
netstat -tlnp | grep 64738

# Test connectivity
telnet your-server-ip 64738

Audio Quality Issues

• Check bandwidth settings
• Verify codec configuration
• Test with different clients
• Monitor CPU usage during peak times

Certificate Problems

# Regenerate SSL certificates
sudo openssl req -new -x509 -keyout /etc/murmur/server.key \
    -out /etc/murmur/server.crt -days 365 -nodes

# Restart service
sudo rc-service murmur restart

Conclusion

You’ve successfully set up voice chat servers on Alpine Linux! Whether you chose Mumble for its open-source nature, TeamSpeak for gaming communities, or Discord Bot for automation, you now have a robust communication platform.

Remember to:

• Regularly backup your server configurations
• Monitor server performance and resources
• Keep software updated for security
• Configure proper access controls
• Test connectivity regularly

Your voice chat server is now ready to serve your community with high-quality, low-latency communication! 🎉

Enjoy your new communication platform! 🎙️