Last active
August 24, 2017 23:44
-
-
Save KensakuKOMATSU/430abf94081cfa9f377a7461eaaf59d7 to your computer and use it in GitHub Desktop.
skyway iot sdk sample configs
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
; General configuration: folders where the configuration and the plugins | |
; can be found, how output should be logged, whether Janus should run as | |
; a daemon or in foreground, default interface to use, debug/logging level | |
; and, if needed, shared apisecret and/or token authentication mechanism | |
; between application(s) and Janus. | |
[general] | |
configs_folder = /opt/janus/etc/janus ; Configuration files folder | |
plugins_folder = /opt/janus/lib/janus/plugins ; Plugins folder | |
transports_folder = /opt/janus/lib/janus/transports ; Transports folder | |
;log_to_stdout = false ; Whether the Janus output should be written | |
; to stdout or not (default=true) | |
;log_to_file = /tmp/janus.log ; Whether to use a log file or not | |
;daemonize = true ; Whether Janus should run as a daemon | |
; or not (default=run in foreground) | |
;pid_file = /tmp/janus.pid ; PID file to create when Janus has been | |
; started, and to destroy at shutdown | |
;interface = 1.2.3.4 ; Interface to use (will be used in SDP) | |
debug_level = 4 ; Debug/logging level, valid values are 0-7 | |
;debug_timestamps = yes ; Whether to show a timestamp for each log line | |
;debug_colors = no ; Whether colors should be disabled in the log | |
;api_secret = janusrocks ; String that all Janus requests must contain | |
; to be accepted/authorized by the Janus core. | |
; Useful if you're wrapping all Janus API requests | |
; in your servers (that is, not in the browser, | |
; where you do the things your way) and you | |
; don't want other application to mess with | |
; this Janus instance. | |
;token_auth = yes ; Enable a token based authentication | |
; mechanism to force users to always provide | |
; a valid token in all requests. Useful if | |
; you want to authenticate requests from web | |
; users. For this to work, the Admin API MUST | |
; be enabled, as tokens are added and removed | |
; through messages sent there. | |
admin_secret = janusoverlord ; String that all Janus requests must contain | |
; to be accepted/authorized by the admin/monitor. | |
; only needed if you enabled the admin API | |
; in any of the available transports. | |
;server_name = MyJanusInstance ; Public name of this Janus instance | |
; as it will appear in an info request | |
; Certificate and key to use for DTLS. | |
[certificates] | |
cert_pem = /opt/janus/share/janus/certs/mycert.pem | |
cert_key = /opt/janus/share/janus/certs/mycert.key | |
; Media-related stuff: you can configure whether if you want | |
; to enable IPv6 support (still WIP, so handle with care), the maximum size | |
; of the NACK queue (in milliseconds, defaults to 1000ms=1s) for retransmissions, the | |
; range of ports to use for RTP and RTCP (by default, no range is envisaged), the | |
; starting MTU for DTLS (1472 by default, it adapts automatically), | |
; if BUNDLE should be forced (defaults to false) and if RTCP muxing should | |
; be forced (defaults to false). | |
[media] | |
;ipv6 = true | |
;max_nack_queue = 1000 | |
;rtp_port_range = 20000-40000 | |
;dtls_mtu = 1200 | |
;force-bundle = true | |
;force-rtcp-mux = true | |
; NAT-related stuff: specifically, you can configure the STUN/TURN | |
; servers to use to gather candidates if the gateway is behind a NAT, | |
; and srflx/relay candidates are needed. In case STUN is not enough and | |
; this is needed (it shouldn't), you can also configure Janus to use a | |
; TURN server; please notice that this does NOT refer to TURN usage in | |
; browsers, but in the gathering of relay candidates by Janus itself, | |
; e.g., if you want to limit the ports used by a Janus instance on a | |
; private machine. Furthermore, you can choose whether Janus should be | |
; configured to work in ICE-Lite mode (by default it doesn't). Finally, | |
; you can also enable ICE-TCP support (beware that it currently *only* | |
; works if you enable ICE Lite as well), choose which interfaces should | |
; be used for gathering candidates, and enable or disable the | |
; internal libnice debugging, if needed. | |
[nat] | |
stun_server = stun.skyway.io | |
stun_port = 3478 | |
nice_debug = false | |
;ice_lite = true | |
;ice_tcp = true | |
; In case you're deploying Janus on a server which is configured with | |
; a 1:1 NAT (e.g., Amazon EC2), you might want to also specify the public | |
; address of the machine using the setting below. This will result in | |
; all host candidates (which normally have a private IP address) to | |
; be rewritten with the public address provided in the settings. As | |
; such, use the option with caution and only if you know what you're doing. | |
; Besides, it's still recommended to also enable STUN in those cases, | |
; and keep ICE Lite disabled as it's not strictly speaking a public server. | |
;nat_1_1_mapping = 1.2.3.4 | |
; You can configure a TURN server in two different ways: specifying a | |
; statically configured TURN server, and thus provide the address of the | |
; TURN server, the transport (udp/tcp/tls) to use, and a set of valid | |
; credentials to authenticate... | |
turn_server = 52.41.145.197 | |
turn_port = 443 | |
turn_type = tcp | |
turn_user = siruuser | |
turn_pwd = s1rUu5ev | |
; ... or you can make use of the TURN REST API to get info on one or more | |
; TURN services dynamically. This makes use of the proposed standard of | |
; such an API (https://tools.ietf.org/html/draft-uberti-behave-turn-rest-00) | |
; which is currently available in both rfc5766-turn-server and coturn. | |
; You enable this by specifying the address of your TURN REST API backend, | |
; the HTTP method to use (GET or POST) and, if required, the API key Janus | |
; must provide. | |
; turn_rest_api = http://iot-turn.skyway.io/api | |
; turn_rest_api_key = demonstrationkey | |
; turn_rest_api_method = GET | |
; You can also choose which interfaces should be explicitly used by the | |
; gateway for the purpose of ICE candidates gathering, thus excluding | |
; others that may be available. To do so, use the 'ice_enforce_list' | |
; setting and pass it a comma-separated list of interfaces or IP addresses | |
; to enforce. This is especially useful if the server hosting the gateway | |
; has several interfaces, and you only want a subset to be used. Any of | |
; the following examples are valid: | |
; ice_enforce_list = eth0 | |
; ice_enforce_list = eth0,eth1 | |
; ice_enforce_list = eth0,192.168. | |
; ice_enforce_list = eth0,192.168.0.1 | |
; By default, no interface is enforced, meaning Janus will try to use them all. | |
;ice_enforce_list = eth0 | |
; In case you don't want to specify specific interfaces to use, but would | |
; rather tell Janus to use all the available interfaces except some that | |
; you don't want to involve, you can also choose which interfaces or IP | |
; addresses should be excluded and ignored by the gateway for the purpose | |
; of ICE candidates gathering. To do so, use the 'ice_ignore_list' setting | |
; and pass it a comma-separated list of interfaces or IP addresses to | |
; ignore. This is especially useful if the server hosting the gateway | |
; has several interfaces you already know will not be used or will simply | |
; always slow down ICE (e.g., virtual interfaces created by VMware). | |
; Partial strings are supported, which means that any of the following | |
; examples are valid: | |
; ice_ignore_list = vmnet8,192.168.0.1,10.0.0.1 | |
; ice_ignore_list = vmnet,192.168. | |
; Just beware that the ICE ignore list is not used if an enforce list | |
; has been configured. By default, Janus ignores all interfaces whose | |
; name starts with 'vmnet', to skip VMware interfaces: | |
ice_ignore_list = vmnet | |
; You can choose which of the available plugins should be | |
; enabled or not. Use the 'disable' directive to prevent Janus from | |
; loading one or more plugins: use a comma separated list of plugin file | |
; names to identify the plugins to disable. By default all available | |
; plugins are enabled and loaded at startup. | |
[plugins] | |
; disable = libjanus_voicemail.so,libjanus_recordplay.so | |
; You can choose which of the available transports should be enabled or | |
; not. Use the 'disable' directive to prevent Janus from loading one | |
; or more transport: use a comma separated list of transport file names | |
; to identify the transports to disable. By default all available | |
; transports are enabled and loaded at startup. | |
[transports] | |
; disable = libjanus_rabbitmq.so |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
[general] | |
;admin_key = supersecret ; If set, mountpoints can be created via API | |
; only if this key is provided in the request | |
[gst-rpwc] | |
type = rtp | |
id = 1 | |
description = RPWC H264 test streaming | |
audio = yes | |
video = yes | |
audioport = 5002 | |
audiopt = 111 | |
audiortpmap = opus/48000/2 | |
videoport = 5004 | |
videopt = 96 | |
videortpmap = H264/90000 | |
videofmtp = profile-level-id=42e028\;packetization-mode=1 |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
; Web server stuff: whether any should be enabled, which ports they | |
; should use, whether security should be handled directly or demanded to | |
; an external application (e.g., web frontend) and what should be the | |
; base path for the Janus API protocol. You can also specify the | |
; threading model to use for the HTTP webserver: by default this is | |
; 'unlimited' (which means a thread per connection, as specified by the | |
; libmicrohttpd documentation), using a number will make use of a thread | |
; pool instead. Since long polls are involved, make sure you choose a | |
; value that doesn't keep new connections waiting. | |
[general] | |
json = indented ; Whether the JSON messages should be indented (default), | |
; plain (no indentation) or compact (no indentation and no spaces) | |
base_path = /janus ; Base path to bind to in the web server (plain HTTP only) | |
threads = unlimited ; unlimited=thread per connection, number=thread pool | |
http = yes ; Whether to enable the plain HTTP interface | |
port = 8088 ; Web server HTTP port | |
;interface = eth0 ; Whether we should bind this server to a specific interface only | |
;ip = 192.168.0.1 ; Whether we should bind this server to a specific IP address (v4 or v6) only | |
https = yes ; Whether to enable HTTPS (default=no) | |
secure_port = 8089 ; Web server HTTPS port, if enabled | |
;secure_interface = eth0 ; Whether we should bind this server to a specific interface only | |
;secure_ip = 192.168.0.1 ; Whether we should bind this server to a specific IP address (v4 or v6) only | |
;acl = 127.,192.168.0. ; Only allow requests coming from this comma separated list of addresses | |
; Janus can also expose an admin/monitor endpoint, to allow you to check | |
; which sessions are up, which handles they're managing, their current | |
; status and so on. This provides a useful aid when debugging potential | |
; issues in Janus. The configuration is pretty much the same as the one | |
; already presented above for the webserver stuff, as the API is very | |
; similar: choose the base bath for the admin/monitor endpoint (/admin | |
; by default), ports, threading model, etc. Besides, you can specify | |
; a secret that must be provided in all requests as a crude form of | |
; authorization mechanism, and partial or full source IPs if you want to | |
; limit access basing on IP addresses. For security reasons, this | |
; endpoint is disabled by default, enable it by setting admin_http=yes. | |
[admin] | |
admin_base_path = /admin ; Base path to bind to in the admin/monitor web server (plain HTTP only) | |
admin_threads = unlimited ; unlimited=thread per connection, number=thread pool | |
admin_http = no ; Whether to enable the plain HTTP interface | |
admin_port = 7088 ; Admin/monitor web server HTTP port | |
;admin_interface = eth0 ; Whether we should bind this server to a specific interface only | |
;admin_ip = 192.168.0.1 ; Whether we should bind this server to a specific IP address (v4 or v6) only | |
admin_https = yes ; Whether to enable HTTPS (default=no) | |
;admin_secure_port = 7889 ; Admin/monitor web server HTTPS port, if enabled | |
;admin_secure_interface = eth0 ; Whether we should bind this server to a specific interface only | |
;admin_secure_ip = 192.168.0.1 ; Whether we should bind this server to a specific IP address (v4 or v6) only | |
;admin_acl = 127.,192.168.0. ; Only allow requests coming from this comma separated list of addresses | |
; Certificate and key to use for HTTPS. | |
[certificates] | |
cert_pem = /opt/janus/share/janus/certs/mycert.pem | |
cert_key = /opt/janus/share/janus/certs/mycert.key |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment