LiveKit Community

Hi david, how to update to latest version? I installed livekit server using init_script.sh on my production. do I run this script again?

if you chose latest in the generate config, simply restart the server :slightly_smiling_face: or start a new VM

ok thanks, livekit is configured as server, so you mean I need to stop and start the service again?

Just found this project, loving what I'm seeing so far (including a bunch of technology choices).

<https://github.com/livekit/server-sdk-go/pull/38> ran into a little docs bug for the go sdk.

Hey Travis, appreciate the kind words. If you don't mind, may I know more about what you’d like to do?

I'm authoring a game and am using ebiten in Go and was hoping to do my state synchronization in Go so it would work both natively and in-browser without writing a separate client implementation.

Aha, I see. It sounds like you’d want a Golang client SDK though, which we currently don’t have. The server SDK wouldn’t help you much in the browser :slightly_smiling_face:

Yeah I suppose so -- I was imagining that some subset of the go sdk could serve some of my purposes.

From the docs, its in the making: <https://docs.livekit.io/references/client-sdks>

We want to save it in DO spaces (S3 compatible storage)

Recording can only be achieved using <https://github.com/livekit/server-sdk-go|server-sdk-go>.

We're using <https://github.com/livekit/server-sdk-js|server-sdk-js> since our backend is in Node(typescript).

<https://github.com/livekit/server-sdk-js/blob/main/src/RecordingServiceClient.ts|https://github.com/livekit/server-sdk-js/blob/main/src/RecordingServiceClient.ts>

Oh. Nice. I was reading the docs <https://docs.livekit.io/references/server-sdks> and the note stated "The Go server SDK also has WebRTC capabilities, allowing you to build publishing, recording, and other track interactions in your apps."

We assumed these services were unique to the sdk.

There may be some things we don't catch (and please file an issue, if discovered!), but our general philosophy/aim is for our SDKs to be consistent across all platforms. Sometimes there are differences specific to a particular platform, but that's usually with the client (not server) SDKs.

hey <@U01KZ0SCDKL>, after we start recording the live stream, what is the actual flow for saving the stream?

Is it something like this?
• Feed keeps sending data to backend;
• Backend points the  feed to a S3 bucket;
• End live recording, stopping the feed and record altogether.
If that's the case, the server needs to be always on, meaning we can't use a serverless approach to it. Are our assumptions correct?

Serveless meaning going to zero (cold start).

Check out the beta docs here: <https://docs.livekit.io/guides/recording/>

So, what's the difference between LiveKit Recorder and <https://github.com/livekit/server-sdk-js|server-sdk-js>?

It seems the latter is easier to configure and use.

Just to be clear, We're using Flutter Client SDK for live streaming, server-sdk-js for everything "server" related.

We're deploying LiveKit (PoC) using VM (Linode Hosting) as per <@U02BBTRGF98> recommended. We'll move to DO with kubernetes for that and to save all records we'll use DO spaces (S3 like storage) and serve them with their CDN.

The question is if We're on the right track or we're missing something else.

Most if not all the streaming will be performed using a mobile device at least for now.

<@U02BBTRGF98> Just following up on the question, do we need to configure live-recorder or can we use server-sdk-js and point it S3 bucket?

that’s a question for <@U01UB0LHTTQ> I think

<@U032JMDR8TD> the recorder runs as a separate service, you can interface with that service through the server SDK, but you still have to run/maintain it.

From the docs:
```While standalone mode is easy to get started, you may want to deploy the recorder as a service for programmatic access to recording. Once deployed, rooms can be recorded by indicating as such during room creation.```

<@U032JMDR8TD> we’ve spent a lot of time (and we’ll be spending more time soon, because there’s a lot of new stuff that’s been released!) on the docs. Please give them a read over and if there’s something that doesn’t make sense, we’re happy to answer questions or offer guidance. :pray:

<@U032JMDR8TD> Did you run this on Linode or other cloud provider? used k8s? it would be great if you can share some knowledge

Hi <@U02UMFKPC6Q>, We're currently running the VM implementation on Linode for our PoC. We haven't implemented live-recorder yet. Our use case doesn't need composite video support so we're following this implementation: <https://github.com/livekit/server-sdk-go/pull/32|Introduce recordbot to record stream directly> by <@U02SGSET1RT>.

For kubernetes, we're deciding between DO and Linode.

hmmm, very interesting, just FYI, linode nodebalaner doesn’t support UDP traffic, I had a chat with their support about that. interested to know how you guys go about it

for the record, if you go with GKE you might want to lower the spec in the sample GKE values, ref: <https://livekit-users.slack.com/archives/C01KVTJH6BX/p1644281370419559>

We're not using load balancers (yet). Thanks for the heads-up. GCP and AWS are really expensive for startups trying to implement livestreaming. That goes for Agora, etc... Now the clear choice is DO. DO has spaces (S3 compatible) + free CDN. We're using Linode for different services and we were evaluating the possibility to implement our streaming services on their platform.

you definitely can. it could be used as the means to distribute messages to all participants. Though LiveKit itself will not keep a history of messages sent. check out <https://docs.livekit.io/guides/room/data#data-messages|data messages>

:wave:  Hi <@U03310M08UB>, welcome!

All I’ll add here is data messages can be broadcasted to everyone in a room, but also fanned out to only a specific set of users. So, you could build both, chat that is sent to everyone and (Group) DM-type functionality, as well.

If you need long-term/permanent persistence for your chat system, you’ll need to supplement what we offer with your own application logic and storage.

I guess you can also use webhooks: <https://docs.livekit.io/guides/webhooks> for a cleaner implementation for chat persistence and other features like analytics / moderation

Hi!
Which client version are you using?
Does it also happen to you with the sample app of the client-sdk-js?

<@U02EU2ZPTQU> I’m using v0.16.6. I haven’t tested with sample app yet but I think it has the same problem.

I'm asking because we recently made changes to mitigate these kind of problems. It sounds like you can reliably reproduce the issue, could you give me step by step instructions how to reproduce it?

Steps to reproduce:
1. Connect to LiveKit server with proper access token &amp; url
2. Toggle mic/camera buttons to see it works
3. Disconnect network and wait a while
4. Toggle mic/camera buttons several times
5. Reconnect network and wait until LiveKit reconnected successfully
6. Toggle mic/camera button =&gt; It doesn’t work

thanks for the detailed steps.
Unfortunately I cannot reproduce the issue. I just tested the scenario you described on chrome for both video and audio. Once LiveKit reconnects the latest state is synced between the two participants and toggling mic/video still works after reconnect.
Would it be possible for you to test with the sample app in the sdk repo ?
`yarn install` and `yarn sample` should be enought to run it.

<@U02RGH0BQT1>, unfortunately Heroku does not work with LiveKit. It's not possible/straight-forward to run UDP based services on it

Digital Ocean is really easy to configure and they have a 60 day trial if you're testing livekit (or any other service for that matter, hehe).

<https://livekit.io/playground#code=d0707b7abae866e48d1f133e> is giving me `ERROR: SERVER WAS NOT REACHABLE`

```curl '<https://demo.livekit.cloud/rtc/validate?access_token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ2aWRlbyI6eyJyb29tSm9pbiI6dHJ1ZSwicm9vbSI6InZpcnRhIiwiY2FuUHVibGlzaCI6dHJ1ZSwiY2FuU3Vic2NyaWJlIjp0cnVlfSwiaWF0IjoxNjQ1MTQ1ODA1LCJuYmYiOjE2NDUxNDU4MDUsImV4cCI6MTY0NTE1MzAwNSwiaXNzIjoiQVBJTW14aUw4cnF1S3p0WkVvWkpWOUZiIiwic3ViIjoidG1jIiwianRpIjoidG1jIn0.FwfMndb1Z-KMhygH6eK9-kvoLhBWxKlzVEhNnLtzoBU&amp;protocol=5&amp;sdk=js&amp;version=0.14.3>' \
  -H 'Connection: keep-alive' \
  -H 'sec-ch-ua: " Not A;Brand";v="99", "Chromium";v="98", "Google Chrome";v="98"' \
  -H 'sec-ch-ua-mobile: ?0' \
  -H 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.80 Safari/537.36' \
  -H 'sec-ch-ua-platform: "macOS"' \
  -H 'Accept: */*' \
  -H 'Origin: <https://livekit.io>' \
  -H 'Sec-Fetch-Site: cross-site' \
  -H 'Sec-Fetch-Mode: cors' \
  -H 'Sec-Fetch-Dest: empty' \
  -H 'Referer: <https://livekit.io/>' \
  -H 'Accept-Language: en-US,en;q=0.9' \
  --compressed```

interesting.. that link is working for me

hmmm, just tried it and it works for me. :thinking_face:

to be clear, i just tried that playground URL in two browser instances and was able to successfully join the same room with two users

it was some traffic MITMing for work that was preventing this (netskope), FWIW

LiveKit will run on pretty much anything :slightly_smiling_face: It consumes ~30MB of memory when idle, and &lt;500MB when maxed out with clients. A single core could take it a long way in terms of simultaneous sessions

It seems Linode is also having this limitation, as per this conversation with <@U02UMFKPC6Q> :

<https://livekit-users.slack.com/archives/C01KZ61HZRR/p1644542663306799?thread_ts=1642638629.038200&amp;cid=C01KZ61HZRR>

Yup, seems either GCP or AWS, GCP worked well with me

It seems Vultr has the same limitation:

&gt; What protocols do you support?
&gt; Vultr Load Balancers support TCP, HTTP, and HTTPS.
<https://www.vultr.com/docs/vultr-load-balancers>

Confirming Vultr, customer support told me they don't have that feature available.

Erick, you do not want to put a load balancer in front of LiveKit UDP ports. instead they need to be exposed and accessible from the internet. See <https://docs.livekit.io/deploy/ports-firewall/#ports|Ports docs>

<@U032JMDR8TD> Please don’t deploy to k8s, my advise is to talk to our friend <@U01KZ61GV5Z> and ask about alternative cloud options :slightly_smiling_face:

As <@U01KZ61GV5Z> mentioned, you don't need any load balancer for UDP.  For my case I'm using haproxy which is handling 443 port &amp; forward to livekit cluster. Everything else is handling by livekit itself because livekit instances have their own IP address &amp; in firewall I opened only UDP port.  For my case I'm also using haproxy for Turn server forward too but I also tried with external turn server.

<@U02UMFKPC6Q>,  GKE is interesting but could be expensive.

Thanks <@U02LCP104CQ>. Are you using a single node?

I tested with different scenario. Honestly I never used K8s. For livekit I'm using multiple servers which is connected with single redis. I used single server to configure haproxy + redis.

I'm following <https://docs.livekit.io/deploy/distributed>

So <@U02LCP104CQ>, you basically configure multiple services (Livekit VM config?) and use redis using that setup, right?

Thanks. I'll try that and see what happens.

It should be pretty straight forward to deploy on Azure. However, I don't know if it'll work on serverless/container instances. This is because we need close-to-the-metal networking access. You should be able to run it on a VM using cloud-init on Azure

i gave up on the container idea because of anticipated poor performance, i took your advice and went with a VM using cloud init.

i went with Standard_F2s size, which is $2 a day but has 2 CPUs and can do accelerated network connection, and i'm very happy with performance

i can give an azure CLI script, or series of commands that will create from scratch, if that would be helpful to anyone

Hi <@U034JTMCB4Y>, how many rooms are you handling with this configuration?

Following <@U02LCP104CQ>'s advice, could this make sense?

----------------------------------------------------------------------
|   Livekit Server ------- Livekit Server --------Livekit Server   |
|             VPS4                    VPS5                             VPS6           |
-----------------------------------------------------------------------
                            \                     |                      /
                               \                  |                   /
                                  \               |                /
                                          --------------
                                             Haproxy
                                                VPS7
                                            -------------
                                                    |
                                                    |
                                                    |
   ____________________________________________________________                              
  |                      VPS1               VPS2                      VPS3                     |
  | --------- Redis (Slave) -- Redis (Master) -- Redis (Slave) ---------- |
  |______________________________________________________________|

There's a PR tackling  failover using redis sentinel:

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

Hi, there is no option to do this by default but you can use a server-sdk to delete the room after a certain time

in this page -&gt; <https://docs.livekit.io/client-sdk-flutter/>

... there's a reference to videoPub.videoQuality = widget.quality;

<@U034JTMCB4Y> yes! we should've had a widget var for the video quality. We'll fix that shortly. In the mean time, you can  swap it out with any <https://docs.livekit.io/client-sdk-flutter/livekit_client/VideoQuality-class.html|VideoQuality> values from the enum

yeah I made it work, i just thought you ought to know  - ty :thumbsup:

<@U034JTMCB4Y> it might be a good idea to submit a PR to fix it for everyone,  have a great day :slightly_smiling_face:

we are working on it! ETA is about a month

Screenshot 2022-02-23 at 23.12.23.png

From the log it's seems like config.yaml file didn't found. You should follow here: <https://docs.livekit.io/deploy/vm/#generate-configuration> "You should have a folder with the following files:"

You can try to rename `livekit.yaml` to `config.yaml`

i deleted the whole and created new one and copy past the content and it works

Have you tried following the guide provided below?
<https://docs.livekit.io/deploy/vm/>

Currently it seems it will be a pain to spin up/down livekit servers for a geographically diverse client base with varying room size requirements, not to mention expensive

<@U02Q4J8KS85> Have you seen the info linked below?
<https://docs.livekit.io/deploy/distributed/>

I have. Those docs assume a uniform node size. I don't want to spin up large nodes in every US region as it's spendy. I want to spin up the livekit control plane on cheap/small nodes and spin up the sfu on demand based on geo location and room size requirements. 

Hey dan, good question. I think you can already achieve this today by using region_aware load balancing.

It supports nodes of various sizing, so you can set a <https://github.com/livekit/livekit-server/blob/master/config-sample.yaml#L163|sysload_limit> so that a node will stop taking requests for new rooms after a certain point

it can get tricky to spin up nodes on demand though, since you'd need the node to be ready when the connect request comes in

Fair point on the ready on request. Perhaps I'll spend some more time thinking through what more granular control over rooms/node sizing looks like for my specific use case. I only need room availability mainly during business hours, and will have varying size rooms: from as low as 2-3 to up to 200ish. I'll also need to good geographic coverage. So with static node size, I obviously have to plan for the worst case which means large nodes in lots of places. Perhaps my best path is to build my own custom k8s controller to spin up the livekit-server specific to my need times and live with the large node sizing.

you could look into an k8s operator that turns up instances of a new Deployment (that has higher CPU requirements). LiveKit is node-size agonistic and does not assume all of the nodes are homogenous in size. The `sysload_limit` config above is a *per CPU* setting.

<@U01KZ61GV5Z> when using distributed set-up, the API key and API Secret need to be the same for all instances?

One approach is to send these over data channels and catch it via room events to update the UI for other participants, if you want to update a db as well you can catch it via webhoohs. HTH

I understand it's desirable for your application to control participant metadata from the client, but because others rely on this security model, it's not a simple feature that can be added.

Long term, we do plan to make this more flexible so clients have much more capabilities around managing shared data.

In the mean time, it seems fairly straight forward to implement it by calling your own backend API. It does add a bit of latency, but it's negligible.

I agree with <@U01KZ61GV5Z>. You can have your own backend &amp; implement this type features. We're also developing conferencing system where we're using seperate backend server to process requests. Later sending changing metadata using backend server directly. After that client can get response on metadata update.

Thanks <@U01KZ61GV5Z> it will surely help maybe in future where we have flags which allows such different behaviours.

The goal is a cross-platform free-to-use chat service similar to Zoom or Teams. No sign up, no login, nothing.

Nice. Do you have a cap on max participants per room?

<@U032JMDR8TD> If you're using API to create room then you'll able to limit users for each room. Have a look here: <https://docs.livekit.io/guides/server-api#createroom>

<@U02LCP104CQ> thanks. I saw that parameter on the SDK. I'm looking for max users per room based on different configurations ( VPS specs, pub qty, subs qty)

Hi <@U02SFES0N9Y>. Are you using k8s or distributed set-up for servers? Also, how many rooms are you handling with your current config?

I'm using DigitalOcean currently but haven't setup any type of scaling yet as I'm still testing and feature adding. And Is the question how many can I handle (technically infinite?), or how many rooms are currently being used (not a lot)? Lol

Hehe. Thanks for responding <@U02SFES0N9Y>. So, you deployed to DO using VM config. My question is how many rooms  is this configuration handling (based on your observations, of course)?

I still have a lot of work to do and haven't really put it out there yet.

We've hit a high of I think 2 rooms with 2 people each. :sweat_smile:

Well, one step at a time, hehe. Is it working? I  created a Room but didn't see the feed. I'm using Brave Browser btw.

Tested working on Chrome, Edge and Safari. It's made in Flutter so native cross-platform is in mind.

This is really awesome <@U02LCP104CQ>! Wonderful work.

This is fantastic! such a simple way to get your own conferencing set up.

Thank you <@U01KZ61GV5Z> <@U02CM28PB4Y> for your all help during development!! Not sure if we're eligible to be listed under awesome livekit usage list :grinning:

of course! glad to see all the cool stuff people are building with it!

we need to catalog all of the projects people are building on top and will for sure include plugNmeet in that list!

hi <@U0351NV02Q5>!
it depends on what you want to build.
the first one is a vanilla-js example without any ui framework dependency, but you could use it with any js-framework that you like.
the second one is the example that makes use of the livekit react component library and depends on react as an ui framework.

Hey <@U0351NV02Q5>,  actually one is built in Javascript &amp; one is built in React. I'd say at this point, it mostly depends on which language you prefer from my understanding. My 2 cents.

OK, understood. I will create containers to the hwllo word, is this a PR that you'd like to get in the repos?

:wave: Jose,

• Pion's single port mode should work fine for smaller scale apps. If you are pushing more than 200mbps, I wouldn't recommend it because it'll run into performance limitations with multiple threads writing into a single port. (FYI, ion-sfu is a separate SFU project, we both use the same underlying Pion WebRTC implementation.)
• Having different storage backends would be great! We'd appreciate the contributions. If you have any questions around it, you can find us in <#C025KM0S1CK|> 

:wave: Matthias! this should be do-able with the existing auth system within LiveKit. When you generate JWT tokens, they include the specific room that they are allowed to join.

Since the token is issued to each user for each room they are connecting to, all of that business logic can remain within your application server

<https://docs.livekit.io/guides/access-tokens#room-permissions|here's a bit> more details on other grants that could be assigned to each token.

Yeah, I also agree the code is well-organized. I'm learning a lot from it!

You can use <https://www.tensorflow.org/js>. You can find lot of tutorials.

One react example: <https://github.com/Volcomix/virtual-background>

I'm also working for our <https://github.com/mynaparrot/plugNmeet-server|Plug-N-Meet> web conferencing system. You can have a look if you're interested this branch: <https://github.com/mynaparrot/plugNmeet-client/tree/topic/virtual-background>. Still WIP