package main
import (
    "github.com/jiyeyuran/mediasoup-go/v2"
    // ... other imports
)
func main() {
    // Create worker
    worker, err := mediasoup.NewWorker("path/to/mediasoup-worker")
    if err != nil {
        panic(err)
    }
// Create router
    router, err := worker.CreateRouter(&mediasoup.RouterOptions{
        // Configure media codecs
    })
// Create WebRTC transport
    transport, err := router.CreateWebRtcTransport(&mediasoup.WebRtcTransportOptions{
        ListenInfos: []mediasoup.TransportListenInfo{
            {Ip: "0.0.0.0", AnnouncedAddress: "your.public.ip"},
        },
    })
// Use the transport to produce/consume media
    // ...
}

A worker is pinned to one CPU core. WorkerPool starts one worker per core (or as many as you ask for) and puts each new router on the next live worker.

Routers on different workers cannot forward media to each other. Put peers that talk to each other on the same router; use Router.PipeToRouter when they cannot share one. You do not have to know which worker each router is on: PipeToRouter keeps the producer id across workers and generates a new one when they share one.

package main
import (
    "context"
    "log"
"github.com/jiyeyuran/mediasoup-go/v2"
)
func main() {
    // 0 means runtime.NumCPU(). WebRtcServer is created with each worker;
    // without UDPReusePort the port is incremented per worker (44444, 44445, …).
    pool, err := mediasoup.NewWorkerPool("/path/to/mediasoup-worker", 0, func(s *mediasoup.WorkerSettings) {
        s.WebRtcListenInfos = []*mediasoup.TransportListenInfo{
            {
                Protocol:         mediasoup.TransportProtocolUDP,
                Ip:               "0.0.0.0",
                AnnouncedAddress: "your.public.ip",
                Port:             44444,
            },
        }
    })
    if err != nil {
        log.Fatal(err)
    }
    defer pool.Close()
// A worker that dies (C++ abort) is replaced with an empty one so later
    // rooms can still use that core. The rooms it hosted are gone.
    pool.OnWorkerDied(func(ctx context.Context, worker *mediasoup.Worker, err error) {
        log.Printf("worker %d died: %v; tell its clients to renegotiate", worker.Pid(), err)
    })
// Default is round-robin. LeastLoaded(nil) picks the worker carrying the
    // fewest producers and consumers; pass your own function to weigh rooms
    // by something the application already tracks.
    pool.SetScheduler(mediasoup.LeastLoaded(nil))
router, err := pool.CreateRouter(&mediasoup.RouterOptions{
        // Configure media codecs
    })
    if err != nil {
        log.Fatal(err)
    }
// ListenInfos and WebRtcServer can both be omitted: the worker's default
    // WebRtcServer is used.
    transport, err := router.CreateWebRtcTransport(&mediasoup.WebRtcTransportOptions{})
    if err != nil {
        log.Fatal(err)
    }
_ = transport
}