LiveKit Community

how can i use the stream as feed to a rtmp server
or any shortcut solution ?

+1, would love to know how to send the stream to a rtmp server for multistreaming to youtube, facebook etc.

Are you on localhost? wss will only work on a server with a ssl cert (or through a load balancer)

Hi Furqan, it's EC2 instance with elastic IP

docker run --rm --network host  -v /home/ubuntu/Caddyfile:/etc/caddy/Caddyfile -v caddy_data:/data  -v caddy_config:/config caddy caddy file-server --domain <http://lks.domain.org|lks.domain.org>

{$DOMAIN} {
    tls {$EMAIL}
    proxy rtc/* localhost:7880 {
	websocket
	transparent
    }
}

&amp;&amp;

{$DOMAIN} {
    tls {$EMAIL}
    reverse-proxy rtc/*  localhost:7880 {
	header_up Sec-WebSocket-Protocol {&gt;Sec-WebSocket-Protocol}
    }
}

I'm not familiar with the particular routing, but SSL termination should be performed before it reaches LiveKit. I would guess it's some configuration issues with your reverse proxy and/or load balancer

I've used Caddy before, i think that config will try to use lets encrypt to generate a cert automatically?

usually this happens after the first request, what's the error you get with the wss? Double check the cert first to see its there.

Thanks <@U01KZ0UETNW> <@U01KZ61GV5Z> for your inputs
This is the error I'm getting:
```Client :
error Could not connect
can't establish a connection to the server at wss://```

I 've used Ngnix(proxy_pass) + Letsencrypt for this kind of reverse proxy, runs just fine.
Like David &amp; Furqan suggested please check ssl first. Also, access/error logs of the ssl host server might help you to fix it.

<@U01KZ0UETNW> I'll try the load balancer approach as suggested by you. Can you tell how to go about it?

I use AWS (elastic load balancer) or cloudflare. you'll need to run livekit on a server and not locally

locally you can just use ws:// and it's fine

Having the entire room layout as a single stream would be ideal. The use-case of this is to allow converting to RTMP and then multi-streaming to platforms like youtube/facebook etc. which opens up the possibility of a lot more applications which can be built using Livekit

Same for my use case: one stream for all participants 

thanks for the feedback! we will take it into consideration when building this

<@U01KZ61GV5Z> +1 for recording to MP4 with the entire room laid out on a grid

<@U01KZ61GV5Z> any update for rtmp output ?

<@U027GNCS0CW> see <https://docs.livekit.io/guides/recording/>

docs still needs a bit of work, but feel free to play with them. more docs here: <https://github.com/livekit/livekit-recorder/>

Ah thanks a lot 
Any idea about latency of live streaming?

values.yaml:
```replicaCount: 1

livekit:
  # port: 7880
  log_level: info
  rtc:
    use_external_ip: true
    # default ports used
    port_range_start: 50000
    port_range_end: 60000
    tcp_port: 7801
  # redis:
  #   address: &lt;redis_host:port&gt;
  # db: 0
  # username:
  # password:
  # one or more API key/secret pairs
  keys:
    myapikey: "apisecret"
  turn:
    enabled: false # TODO: ADDRESS THIS BECAUSE PEOPLE WITH CERTAIN FIREWALL CONFIGURATIONS WILL NOT BE ABLE TO CONNECT
    # must match domain of your tls cert
    domain: <http://turn.myhost.com|turn.myhost.com>
    # must be 443 if turn load balancer is disabled
    tls_port: 3478
    secretName: &lt;tlssecret&gt;
    # valid values: disable, aws, gke
    # tls cert and domain are required, even when load balancer is disabled
    loadBalancerType: disable

loadBalancer:
  # create
  # valid values: disable, alb, aws, gke
  # in order to use alb, aws-ingress-controller must be installed
  # <https://docs.aws.amazon.com/eks/latest/userguide/alb-ingress.html>
  type: aws
  # Uncomment and enter host names if TLS is desired.
  # TLS is not supported with alb load balancers
  tls:
    - hosts:
        - <http://infra.catalyst.io|infra.catalyst.io>
    # with ALB, certificates needs to reside in ACM for self-discovery
    # with GKE, specify one or more secrets to use for the certificate
    # see: <https://cloud.google.com/kubernetes-engine/docs/how-to/ingress-multi-ssl#specifying_certificates_for_your_ingress>
    #   secretName: &lt;mysecret&gt;

# when true (default), optimizes network stack for service
# increases UDP send and receive buffers
# optimizeNetwork: true

# autoscaling requires resources to be defined
autoscaling:
  # set to true to enable autoscaling. when set, ignores replicaCount
  enabled: false
  minReplicas: 1
  maxReplicas: 5
  targetCPUUtilizationPercentage: 60

# if LiveKit should run only on specific nodes
# this can be used to isolate designated nodes
nodeSelector:
  {}
  # <http://node.kubernetes.io/instance-type|node.kubernetes.io/instance-type>: c5.2xlarge

resources:
  {}
  # Due to port restrictions, you can run only one instance of LiveKit per physical
  # node. Because of that, we recommend giving it plenty of resources to work with
  # limits:
  #   cpu: 6000m
  #   memory: 2048Mi
  # requests:
  #   cpu: 4000m
  #   memory: 1024Mi```

hey <@U027W8HV152> see <https://docs.livekit.io//guides/access-tokens|https://docs.livekit.io//guides/access-tokens> for token generation

after the helm chart runs, it should've given you a command to run to get the load balancer address

the command yields a pending ip address (has been pending for 5+ hours), is this the correct output?

interesting, that means your Kubernetes wasn't able to create the load balancer. Also, it looks like you are also using a standard network load balancer (type `aws` is L4). With L4 load balancers, it wouldn't be able to terminate SSL

The resource that we create is described in this doc: <https://docs.aws.amazon.com/eks/latest/userguide/network-load-balancing.html>
Is it possible that the subnets aren't tagged like they require?

<@U01KZ61GV5Z> i originally installed the chart without a load balancer and then ran helm upgrade with the load balancer configured in values.yaml, could this be a potential source of the problem?

<@U027W8HV152> upgrades like that usually would work ok, but with kubernetes, anything's possible :shrug: .

on your kube cluster, do you have ALB controller installed?

if so using the `alb` load balancer is much better.

i redeployed using alb and enabled turn and now i get this output:

ALB takes a few mins to initialize.. if it still doesn't create, I think we'll need to dig into ALB controller logs to see what's going onn

For my installation, the alb controller is deployed to `kube-system/aws-load-balancer-controller`, Pod logs should indicate what is happening with the Ingress resource

where would i be able to dig into those logs?

the status is pending, so all the required resources may not be provisioned

sorry for long logs, wanted to make sure I gave enough context

Running on MacOS 11.1, here is my command to run the docker as well
```docker run --rm   -p 7880:7880 -p 7881:7881 -p 7882:7882/udp -e LIVEKIT_KEYS="blah: blah"   livekit/livekit-server --dev   --node-ip=&lt;ipaddress&gt;```

```2021-07-14T19:14:04.237Z        INFOserver/main.go:188      configured key provider     {"num_keys": 1}
2021-07-14T19:14:04.238Z        INFOserver/main.go:237      using single-node routing
2021-07-14T19:14:04.239Z        INFOservice/server.go:172   starting LiveKit server     {"address": ":7880", "node": "ND_fyHCBMf0", "nodeIP": "10.126.40.121", "version": "0.10.6", "rtc.tcp_port": 7881, "rtc.udp_port": 7882}
2021-07-14T19:15:15.037Z        DEBUG       service/roommanager.go:271 starting RTC session     {"room": "english", "node": "ND_fyHCBMf0", "participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2", "plan_b": false, "protocol": 2}
2021-07-14T19:15:15.075Z        INFOrtc/room.go:191 new participant joined      {"id": "PA_Xk4JKF9yxrmv", "participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2", "roomId": "RM_VjEzdMBrDTvf"}
2021-07-14T19:15:15.079Z        INFOservice/rtcservice.go:130       new client WS connected     {"connectionId": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2", "room": "RM_VjEzdMBrDTvf", "roomName": "english", "participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2"}
2021-07-14T19:15:15.119Z        DEBUG       rtc/participant.go:248  answering pub offer {"state": "JOINING", "participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2"}
2021-07-14T19:15:15.128Z        DEBUG       rtc/participant.go:268  sending answer to client    {"participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2"}
2021-07-14T19:15:15.128Z        DEBUG       rtc/participant.go:647  updating participant state  {"state": "JOINED", "participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2"}
2021-07-14T19:15:15.130Z        DEBUG       rtc/room.go:164 participant state changed   {"state": "JOINED", "participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2", "oldState": "JOINING"}
2021-07-14T19:15:15.153Z        DEBUG       rtc/participant.go:629  sending ice candidates      {"participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2", "candidate": "udp4 host 10.126.40.121:7882"}
2021-07-14T19:15:15.161Z        DEBUG       rtc/participant.go:629  sending ice candidates      {"participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2", "candidate": "tcp4 host 10.126.40.121:7881"}
2021-07-14T19:15:15.175Z        DEBUG       rtc/participant.go:647  updating participant state  {"state": "ACTIVE", "participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2"}
2021-07-14T19:15:15.175Z        DEBUG       rtc/room.go:164 participant state changed   {"state": "ACTIVE", "participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2", "oldState": "JOINED"}
2021-07-14T19:15:15.363Z        DEBUG       service/roommanager.go:399 add track request        {"participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2", "track": "22cc9888-5378-4992-a696-1b1b0ade8141"}
2021-07-14T19:15:15.418Z        DEBUG       rtc/participant.go:248  answering pub offer {"state": "ACTIVE", "participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2"}
2021-07-14T19:15:15.423Z        DEBUG       rtc/participant.go:268  sending answer to client    {"participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2"}
2021-07-14T19:15:15.623Z        DEBUG       rtc/participant.go:701  mediaTrack added    {"participant": "t9sMJ2dHnfS2N8mjAqXeRmxp3CC2", "remoteTrack": "22cc9888-5378-4992-a696-1b1b0ade8141", "rid": ""}
2021-07-14T19:15:15.624Z        DEBUG       buffer/buffer.go:182    NewBuffer   {"MaxBitRate": 3145728}
2021-07-14T19:15:20.731Z        DEBUG       service/roommanager.go:271 starting RTC session     {"room": "english", "node": "ND_fyHCBMf0", "participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2", "plan_b": false, "protocol": 2}
2021-07-14T19:15:20.735Z        INFOrtc/room.go:191 new participant joined      {"id": "PA_6dcPvgqh5fE2", "participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2", "roomId": "RM_VjEzdMBrDTvf"}
2021-07-14T19:15:20.738Z        INFOservice/rtcservice.go:130       new client WS connected     {"connectionId": "FqbtoPdfBRX8dfuOy61k9KHjZTy2", "room": "RM_VjEzdMBrDTvf", "roomName": "english", "participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2"}
2021-07-14T19:15:20.811Z        DEBUG       rtc/participant.go:248  answering pub offer {"state": "JOINING", "participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2"}
2021-07-14T19:15:20.823Z        DEBUG       rtc/participant.go:268  sending answer to client    {"participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2"}
2021-07-14T19:15:20.823Z        DEBUG       rtc/participant.go:647  updating participant state  {"state": "JOINED", "participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2"}
2021-07-14T19:15:20.823Z        DEBUG       rtc/room.go:164 participant state changed   {"state": "JOINED", "participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2", "oldState": "JOINING"}
2021-07-14T19:15:20.844Z        DEBUG       rtc/participant.go:629  sending ice candidates      {"participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2", "candidate": "udp4 host 10.126.40.121:7882"}
2021-07-14T19:15:20.847Z        DEBUG       rtc/participant.go:629  sending ice candidates      {"participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2", "candidate": "tcp4 host 10.126.40.121:7881"}
2021-07-14T19:15:25.900Z        INFOservice/rtcservice.go:116       WS connection closed        {"participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2", "connectionId": "FqbtoPdfBRX8dfuOy61k9KHjZTy2"}
2021-07-14T19:15:25.900Z        DEBUG       service/roommanager.go:369 RTC session finishing    {"participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2", "room": "english"}
2021-07-14T19:15:25.901Z        DEBUG       rtc/participant.go:647  updating participant state  {"state": "DISCONNECTED", "participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2"}
2021-07-14T19:15:25.901Z        DEBUG       rtc/room.go:164 participant state changed   {"state": "DISCONNECTED", "participant": "FqbtoPdfBRX8dfuOy61k9KHjZTy2", "oldState": "JOINED"}```


are you using distinct tokens for each user?

If not that could be an issue, participant identity (and therefore tokens) would have to be unique

yes each user should be getting a distinct token, as I am using UIDs to create them. Let me double check that though.

ok, just checking.. are there any other differences between the two users that are joining?

yes same client sdk, and all was good with this for me about two days ago too. Let me check the tokens fast

looking at the logs, I do see distinct participant IDs.. so it's not due to that.. looks like the first participant remains connected, but the second one gets kicked off?

yes that is the case, first participant is able to stay in and remains connected, but the second joins for about 3 seconds, renders on the first participants screen as a new user. But never actually renders on their own screen.

looks like client initiated the disconnect.. and it wasn't able to establish an ICE / WebRTC connection

are the two clients using the same browser and running on the same network/machine?

two clients are using the same browser, one on incognito to be able to log in as new user. On the same machine

Okay so joining the first user from incognito is not working either anymore, so that seems to be the issue I'd presume

Any docs you could possible point me to about testing on one machine? 

ah ha, let me check out incognito.. that might be the issue

you can use a different browser? I test between multiple tabs since our test environments aren't session-aware

ah kk didn't even think of that, appreciate the help as always

just tried incognito.. and it's working well for me too. it's possible something else is going on. This is a helpful page to diagnose connectivity: <chrome://webrtc-internals/>

yeah I just tested on safari and that didn't work for me, it has to be something else

No safari isn't connecting either, very weird because I was able to connect from incognito yesterday, and haven't done anything with token generation and I'm just running the docker instance.

And even if I run the docker instance and connect for the first time from incognito with nobody else in the room, I'm unable to connect

hmm, that sounds really strange.. can you check webrtc-internals? if you open that page first, before attempting to connect, it should show you a tab for the connection made

image.png

was able to get these logs for the incognito connection, but don't really have any experience debugging webRTC. Will try to decipher this myself but if you see anything in here that looks promising I'd appreciate it. Thanks again for all the help

so what would be useful is if you can expand the nodes that say `icecandidate (host)` and `addIceCandidate (host)`. those represent the pairs that are used to establish the connection (icecandidate is from Chrome, and addIceCandidate is from LK server)

Just got back to working on the project, and all is well. Very weird lol. Thank you so much for the support anyways

<@U01KZ61GV5Z> Any idea when the flutter api will relesase?

<@U027GNCS0CW> we've started work on it, aiming to get a beta out in two weeks

The opposite actually. LiveKit is an SFU, so all participants connect to the LiveKit server and the server handles the routing of tracks to/between each participant.

Or are you asking if LiveKit supports p2p, <@U027GNCS0CW>?

yes i know about sfu .
my question is if LiveKit supports p2p ?

Ah, ok, I understand. LiveKit doesn't support p2p yet. May I ask the reason you would like it to? Cost savings or something else?

yes , i really like the api/sdk of liveroom , i was waiting for something like that .
i created some product with p2p webrtc with own turn server .
so i m trying to use livekit as my goto solution for webrtc .
thats why i m asking if the same sdk provide a solution for p2p it will be great for my all product

so for p2p i know we have to consider some feature like recording

Hey Sami! We don’t have SIP call-in yet, but it’s definitely something we’ll consider adding, especially if that will help people make the switch!

That's great to hear! That seems to be the only missing feature that we'd need to do the switch. For now I'll continue playing around with LiveKit and see if I can get some better understanding of SIP myself :slightly_smiling_face:

There is an example for Pion here: <https://github.com/pion/example-webrtc-applications/tree/master/sip-to-webrtc>

We have a use case where one participant(android) has to publish in H264 because Vp8 encode performance is bad on the device.

<@U028WHPHSBW>, it's possible, but there's a bug currently preventing this from working as designed.
for now we recommend sticking with a single codec per room. You can restrict the codec allowed in rooms <https://github.com/livekit/livekit-server/blob/master/config-sample.yaml#L72|from config>

Additionally, I was going through the android client sdk and couldn't see any option to select the codec type. I'm assuming this is not provided right now.

you mean trying to specify the codec just for a single user? currently our codec controls are for each room, but we could definitely consider adding controls for each participant

I think that's business logic that you'd have to implement yourself using either data tracks or ws

yeah, we can restrict (from the server side) if a user can publish anything at all. but the server-side doesn't know if the user is sharing video vs screen.

while we can add in some enforcement on the client level within the SDK, it's probably not different than the application doing it (since a we see a video track just as video)

Alright that helps me already a lot.
There is one more thing: When I am giving a user the permission to be the roomAdmin - what does it exactly do? I mean when I for example want to remove a Partipiciant from a room, I do it with the RoomServiceClient in my backend and I dont need the accesToken for that - where the permission is safed.

Moreover the roomAdmin is in the RoomServiceClient always on true

you don't want to or need to give any room participants admin permissions.. it's really only used for the Room APIs

yeah, the docs specify the required permissions for each API. <https://docs.livekit.io/guides/server-api#apis>

Thanks David!
Now I feel ready to finish my project :slightly_smiling_face:

hey <@U028MRA31JA> happy to help! mind threading the conversation here?

I set up a bunch of inbound rules hoping i could get through.
Screen Shot 2021-07-22 at 12.39.42 AM.png 



[12:40 AM] i’m trying to get this working on AWS ec2
[12:40 AM] i’ve not tried the localhost route as I need to demo / test this out on internet
[12:40 AM] any help would be awesome.
[12:41 AM] what i get when i start
```2021-07-22T04:36:33.153Z	INFO	server/main.go:193	configured key provider	{"numKeys": 1}
2021-07-22T04:36:33.155Z	INFO	server/main.go:226	using multi-node routing via redis	{"addr": "localhost:6379"}
2021-07-22T04:36:33.156Z	DEBUG	routing/redisrouter.go:327	starting redisWorker	{"nodeID": "ND_ar5CLWMk"}
2021-07-22T04:36:33.157Z	INFO	service/server.go:172	starting LiveKit server	{"addr": ":7880", "nodeID": "ND_ar5CLWMk", "nodeIP": "xx.xx.xx.xx", "version": "0.11.0", "rtc.portTCP": 7881, "rtc.portICERange": [50000, 60000]}```

so, looks like the request isn't reaching your server at all

so that is what is fuzzy. i’ve done WSS before on AWS many times

can you try hitting `https://&lt;yourdomain&gt;.com` ?

if it can reach the livekit servers, it should load a webpage

Here are the Participants I get with ListPartcipants

And this is the identity and RoomName I give to the server.

Hey Kevin, this is a bug with local router (i.e. not using Redis). We'll fix shortly

this is fixed in a snapshot on dockerhub `v0.11.1-SNAPSHOT`

<https://github.com/livekit/livekit-server/pull/67>

Does anyone have a bundle.js for the vanilla JS version on client?

I attempt to bundle and even with deps in order (i think)… I get
```ERROR in ./sample.ts 19:13
Module parse failed: Unexpected token (19:13)
You may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See <https://webpack.js.org/concepts#loaders>
| import { DataPacket_Kind } from '../src/proto/livekit_rtc';
| 
&gt; const $ = (id: string) =&gt; document.getElementById(id);
| 
| declare global {
webpack 5.46.0 compiled with 1 error in 146 ms```

Idk what bundle.js is but any reason you're not using something like parcel? Very litle config

Oh just noticed it says webpack in the logs

Can you share your config? Looks like it's trying to parse ts as js

we do publish <https://docs.livekit.io/guides/deploy#prometheus|prometheus stats>, which you could use. Prometheus automatically exports node metrics like CPU/memory usage

yes, you would need a different domain for turn, we have <https://docs.livekit.io/guides/deploy#domain-ssl-certificates-and-load-balancer|some docs> on this.

<@U01KZ61GV5Z> I managed to set up TURN but seeing these TURN errors in the logs:

```{"level":"info","ts":1627725535.4178698,"caller":"server/main.go:193","msg":"configured key provider","numKeys":1}
{"level":"info","ts":1627725535.4181967,"caller":"server/main.go:226","msg":"using multi-node routing via redis","addr":"XXXXXXXXXX"}
{"level":"info","ts":1627725535.7533846,"caller":"service/turn.go:88","msg":"Starting TURN server","turn.portTLS":443,"turn.portUDP":3478}
{"level":"info","ts":1627725535.899771,"caller":"service/server.go:172","msg":"starting LiveKit server","addr":":7880","nodeID":"ND_eiXMAKD5","nodeIP":"168.119.168.156","version":"0.11.1","rtc.portTCP":7801,"rtc.portICERange":[50000,60000],"portPrometheus":6789}
{"level":"info","ts":1627725708.9375768,"caller":"service/rtcservice.go:151","msg":"new client WS connected","connID":"CO_8cqNmFMZi37r","roomID":"RM_qhfSQcVUqoUW","room":"myroom","participant":"huzaifah"}
{"level":"info","ts":1627725709.3722157,"caller":"rtc/room.go:190","msg":"new participant joined","pID":"PA_rQq663E7cNuu","participant":"huzaifah","room":"myroom","roomID":"RM_qhfSQcVUqoUW"}
turn ERROR: 2021/07/31 10:01:52 error when handling datagram: failed to handle Allocate-request from 86.179.233.167:56315: relay already allocated for 5-TUPLE
turn ERROR: 2021/07/31 10:01:52 error when handling datagram: failed to handle Allocate-request from 86.179.233.167:56315: relay already allocated for 5-TUPLE
turn ERROR: 2021/07/31 10:01:52 error when handling datagram: failed to handle Allocate-request from 86.179.233.167:56315: relay already allocated for 5-TUPLE```
Relevant values.yaml part:

```  turn:
    enabled: true
    # must match domain of your tls cert
    domain: turn.livekit.XXXXXXXXXX
    # must be 443 if turn load balancer is disabled
    tls_port: 443
    secretName: turn-tls
    # valid values: disable, aws, gke
    # tls cert and domain are required, even when load balancer is disabled
    loadBalancerType: disable```

Regarding Prometheus, I can see stats like total participants and total rooms. However, I was looking for something more granular like "worker-node-71 has 12 participants, 2 rooms, CPU usage 20% and memory usage 15%". Data like this could be presented in JSON.

Also, I've noticed that the "main" Kubernetes pod (the one without `sysctl`in its name) can move around to different nodes. If it's not on the master node, accessing metrics via `DOMAIN:6789/metrics` doesn't work and I have to use the IP of the worker node itself. Is there a way around this unpredictable behaviour?

hey <@U0285NATE1E>, can you file an issue for the TURN error? if you can include details about the browser/client version, that'd help. I haven't seen this error personally, but I do see a Pion issue that might be related.

Regarding stats, are you configuring a prometheus scraper for it? If so, memory/cpu stats are automatically captured. I'm open to surfacing some of this as a JSON endpoint too and would welcome PRs around this.

For the issue with alternating IP addresses, you can configure a rule with the kubernetes prometheus install to scrape LiveKit pods. <https://github.com/prometheus-operator/prometheus-operator/blob/master/Documentation/user-guides/getting-started.md|Prometheus operator> is worth checking out.

You can add `db` in the redis config:
```  redis:
    address: &lt;redis_host:port&gt;
    db: 0
    username: &lt;username&gt;
    password: &lt;password&gt;```

For a single room with 3k participants, redis should only need a few MB. We use a cache.t3.small on AWS, but you could probably use a cache.t3.micro without issue

if you remove LiveKitRoom from the DOM, it should disconnect. similarly, if using useRoom, the compnent that created it can be removed from DOM

hey Scott, I'm not sure what you mean? usually you would add `livekit-client` to your JS project, then for it to bundle into a single js.

are you talking about the sample app? or your own?

in order to disable the camera indicator, you'd have to unpublish local video tracks and then stop them

hey <@U028SSAKLQ1>, welcome to the community! OnDataReceived was implemented just recently in a <https://github.com/livekit/server-sdk-go/pull/7|PR>, and we have yet to release a tagged version for it. Are you using v0.5.12 by any chance?

hi <@U01KZ61GV5Z>, thanks so much for the quick response. yes, i am indeed using v0.5.12

ah ha, that's it then. let me tag v0.5.13 now and push it

`v0.5.13` pushed, see if that works for you

Thank you so much, I'll check it out first thing in the morning!

I'm pretty sure that solves my issues, but I'll post a quick confirmation anyway.

Everything works now as expected. Again, thank you so much for the fast reaction, <@U01KZ61GV5Z>!

it's coming together :slightly_smiling_face: we would like to do a beta with this community in a few days. stay tuned.

Here's a snippet from my dev environment to proxy livekit and TURN through nginx. With it you can use the same interface for multiple domains on port 443 (TURN must listen on port 443 to work reliably):
```upstream livekit_http {
    server localhost:7880;
}

upstream livekit_turn {
    server localhost:5349;
}

server {
    listen 443 ssl;

    server_name <http://livekit.domain.xyz|livekit.domain.xyz>;
    ssl_certificate /path/to/ssl.crt;
    ssl_certificate_key /path/to/ssl.key;

    location / {
        proxy_pass <http://livekit_http>;
    }
    location /rtc {
        proxy_pass <http://livekit_http>;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "Upgrade";
        proxy_set_header Host $host;
    }
}

server {
    listen 443 ssl;

    server_name <http://livekit-turn.domain.xyz|livekit-turn.domain.xyz>;
    ssl_certificate /path/to/ssl.crt;
    ssl_certificate_key /path/to/ssl.key;

    location / {
        proxy_pass <https://livekit_turn>;
    }
}```

you're welcome, let me know should you run into any problems with it!

Preet, my guess is the ports aren't forwarded correctly. can you paste ur config in the thread?

Hey <@U01KZ61GV5Z>, Figured it out

The node_ip was not passed, I didn’t realise how serious of a requirement that was

A warm hi to all and a big THANK YOU to LiveKit Team for making our lives so much simpler

A quick cross-check with the audience here