RTSP to WebRTC Video Streaming using Kurento Media Server(Docker Image) and Coturn(Docker Image) in GCP: TURN Server Blocking at FIRST TIME?

Question

I'm developing web streaming client and server. Technical stacks are follows:

• GCP
• Docker, Docker Compose
• Kurento Media Server
• Coturn
• Node.js (Backend)
• React.js (Frontend)
• NGINX

In GCP, I dockerized Node.js and React.js projects, and pull docker images: Kurento Media Server, Coturn and NGINX. And I made docker-compose file, build and execute.

In test process, I have found followings:

1. After running all services with Docker Compose for the first time, if I connect to a browser and receive streaming, real-time streaming is well performed.
2. After that, if I do not quit Docker Compose Running, refresh the browser and then request streaming for the same video again, real-time streaming is NOT performed!
3. However, if I do not refresh the browser and then request streaming again for a video that cannot be streamed, real-time streaming occurs normally AGAIN...!

In this context, I have wondered about streaming packets. So I have tested, and following results are shown:

1. For above 1 and 3, the process of binding the user to the TURN server as soon as the request starts, and starting to receive streaming packets from the streaming server.
2. Regarding above 2, even if the request is initiated, the handshaking process with the TURN server is not performed, and the streaming packet is not received from the streaming server.

May I ask you for help..? TT

---

There are some codes and configurations for help:

docker-compose.yml

#
# ...
#

kms:
    container_name: kms
    restart: always
    image: kurento/kurento-media-server:latest
    hostname: kurento
    container_name: kms-latest
    ports: 
        - '8888:8888'
    environment: 
        - KMS_STUN_IP=<myturnip>
        - KMS_STUN_PORT=<myturnport>
        - KMS_TURN_URL=<myturnuser:myturnpw@myturnip:myturnport>
    
coturn:
    container_name: coturn
    restart: always
    build: 
        dockerfile: Dockerfile
        context: ./coturn
    network_mode: host

#
# ...
#

coturn Dockerfile

FROM coturn/coturn:latest
WORKDIR /usr/app

COPY ./turnserver.conf /etc/coturn/turnserver.conf
COPY ./coturn /etc/default/coturn

RUN turnadmin -O -r <myrealm> -o <myorigin>
RUN turnadmin -a -u <myturnuser> -p <myturnpw> -r <myrealm>

turnserver.conf

external-ip=<mypublicip>

listening-port=3478
tls-listening-port=5349

fingerprint
lt-cred-mech

realm=<myrealm>
user=<myturnuser:myturnpw>

log-file=/var/log/turnserver/turnserver.log
simple-log

no-cli
total-quota=0
bps-capacity=0
stale-nonce

coturn log

...

coturn | 1: IPv4. UDP listener opened on: ::1:3478
coturn | 1: Total General servers: 4
coturn | 1: SQLite DB connection success: /var/lib/cotun/turndb
coturn | 1: IO method (auth thread): epoll (with changelist)
coturn | 1: IO method (admin thread): epoll (with changelist)
coturn | 1: IO method (auth thread): epoll (with changelist)
coturn | 1: ERROR:
coturn | 1: Could not start Prometheus collector!
coturn | 33: IPv4. tcp or tls connected to: ...

...

Answer 1

I solved this issue! I found that in client side (Kurento Util JS), there is a configuration.

Before Correction

const video = getVideo();
const options = {
    remoteVideo: video,
    onicecandidate: onicecandidate
}

webRtcPeer = WebRtcPeer.WebRtcPeerRecvonly(options, error => {
    if (error) {
        Logger.error(error);
        reject(error);
    }
});

After Correction

const video = getVideo();
const options = {
    remoteVideo: video,
    onicecandidate: onicecandidate,
    configuration: {
        iceServers: [
            {
                urls: "turn:myturnip:myturnport",
                username: "myturnuser",
                credential: "myturnpw"
            }
        ]
    }
}

webRtcPeer = WebRtcPeer.WebRtcPeerRecvonly(options, error => {
    if (error) {
        Logger.error(error);
        reject(error);
    }
});