In this guide, we’ll create an Always Free Arm based VM on OCI and use it to deploy the official TeamSpeak 6 server container. Before we begin, you’ll need to create a free Oracle Cloud account. A credit card is required to register, but you won’t be charged as long as you follow the tutorial below.

You will build a very small setup consisting of one OCI VM (VM.Standard.A1.Flex), Docker running on the VM with a single container with the TS6 server.

Create an Always Free Ampere VM

Sign in to the OCI console, then click “Create a VM instance” on the homepage.

Give the instance a name, for example ts6-server. Under Shape, leave the default Oracle Linux image selected. Click Change Shape, choose VM.Standard.A1.Flex under the Ampere Shape series. Set OCPU and memory values that fit within the Always Free limits.

In the networking section, select the option to Create new virtual cloud network. In the Add SSH keys, do not forget to download both the private and public key.

Then, select Next until you can click Create.

Wait for the instance to switch to the Running state. On the instance details page, note the Public IP address. You will use it to connect through SSH and later from the TeamSpeak client.

Connect to the VM using SSH

For Oracle Linux images in OCI, the default username is opc. On macOS or Linux, open a terminal. On Windows, use a terminal with OpenSSH support or a tool like PuTTY.
Example SSH command:
ssh -i /path/to/your/private_key opc@YOUR_PUBLIC_IP
If this is the first connection, accept the host key fingerprint.

Update the system and install Docker

First update all packages and reboot:

sudo dnf update -y
sudo reboot

Reconnect with SSH after the reboot, then install Docker Engine.
Install the dnf-plugins-core package:

sudo dnf install -y dnf-plugins-core

Add the official Docker CE repository for RHEL compatible systems:

sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

Remove any conflicting packages such as older Docker or Podman:

sudo dnf remove -y docker docker-client docker-client-latest docker-common  docker-latest docker-latest-logrotate docker-logrotate docker-engine podman runc

Install Docker Engine and the Compose plugin:

sudo dnf install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin --allowerasing

Enable and start the Docker service:

sudo systemctl enable --now docker

Verify installation:

docker version
docker compose version

You should see version information for both commands.

Enable x86 containers on the Arm VM

The official TeamSpeak 6 server image teamspeaksystems/teamspeak6-server:latest is published for linux/amd64. Your OCI VM is Arm based, so Docker needs multi architecture support to run x86 containers. The easiest way I found is to use binfmt_misc together with the tonistiigi/binfmt helper.

Run the following commands as opc:

# ensure binfmt_misc module and filesystem are available
sudo modprobe binfmt_misc || true
sudo mkdir -p /proc/sys/fs/binfmt_misc
sudo mount -t binfmt_misc binfmt_misc /proc/sys/fs/binfmt_misc || true

# install amd64 emulation support for Docker
sudo docker run --privileged --rm tonistiigi/binfmt --install amd64

Test that x86 containers run correctly:

sudo docker run --rm --platform=linux/amd64 debian:stable-slim uname -m

If everything is configured correctly, the output should be:

x86_64

That confirms your Arm VM can run x86 containers and you are ready for the TeamSpeak server.

Create the TeamSpeak 6 Docker Compose project

Create a directory for the server:

mkdir -p ~/ts6
cd ~/ts6

Create a docker-compose.yml file:

cat > docker-compose.yml << 'EOF'
services:
  teamspeak:
    image: teamspeaksystems/teamspeak6-server:latest
    container_name: teamspeak6-server
    restart: unless-stopped
    platform: linux/amd64
    ports:
      - "9987:9987/udp"    # voice
      - "30033:30033/tcp"  # file transfer
    environment:
      - TSSERVER_LICENSE_ACCEPTED=accept
    volumes:
      - teamspeak-data:/var/tsserver/

volumes:
  teamspeak-data:
    name: teamspeak-data
EOF

What this configuration does, in short:

  • Pulls the official TeamSpeak 6 Server image published by TeamSpeak.
  • Forces the container to run as linux/amd64 inside your Arm VM.
  • Exposes the default voice port 9987 over UDP and the file transfer port 30033 over TCP, matching the upstream recommendations (which you can view here).
  • Persists configuration and database files in a named Docker volume teamspeak-data.
  • Automatically restarts the container unless you stop it manually.

Start the TeamSpeak 6 server

From the ~/ts6 directory, pull the image and start the server in the background:

sudo docker compose pull
sudo docker compose up -d

Check that the container is running:

sudo docker compose ps

To read the startup logs and capture your admin credentials, run:

sudo docker logs teamspeak6-server | tail -n 80

On first startup you will see output similar to:

Server Query Admin Account created
loginname= "serveradmin", password= "someRandomPassword"
apikey= "someApiKey"
VirtualServer |1 |ServerAdmin privilege key created, please use the line below
token=SomeGeneratedTokenValue

Write down:

  • loginname and password for server query admin
  • token which is your ServerAdmin privilege key

You will use the token once when you first connect from the client to become server admin.
If the log seems to end after this message: Precomputing puzzle, this may take some seconds… wait a few minutes and run the docker logs command again.

Open ports in OCI and on the VM

The container listens on ports 9987 and 30033, but network security still blocks traffic until you open these ports in:

  • The VCN security list
  • The Oracle Linux firewall on the VM

Open ports in the VCN security list

  • In the OCI Console, open your instance details page.
  • In the Primary VNIC section, click the subnet name.
  • In the subnet view, click Security Lists, then click the security list attached to the subnet (for many simple setups this is the default security list).

Click Add Ingress Rules and create these rules:

Rule 1, voice traffic
Source CIDR: 0.0.0.0/0
IP Protocol: UDP
Destination Port Range: 9987
Rule 2, file transfer
Source CIDR: 0.0.0.0/0
IP Protocol: TCP
Destination Port Range: 30033

Save the changes. (You can also implement the same rules using network security groups if that fits your network design better.)

On the VM, open the same ports in firewall:

sudo firewall-cmd --permanent --add-port=9987/udp
sudo firewall-cmd --permanent --add-port=30033/tcp
sudo firewall-cmd --reload

Congratulations, you now have end to end connectivity from the internet to the TeamSpeak server container.

Connect from the TeamSpeak 6 client

Install the TeamSpeak 6 client from the official downloads page if you have not already.
Then, open the client. Create a new connection or server profile. Use the public IP of your OCI instance as the server address. Connect.

  • When the client prompts you for a privilege key, paste the token value you copied from the server logs.

After that, your user becomes a ServerAdmin on that virtual server and you can:

  • Create and organize channels
  • Adjust permissions
  • Invite friends by sharing the IP or a bookmark

Remember this is a beta server. At the time of writing, the server license included in the container allows 32 slots and automatically renews during the beta period.