Akka.Remote Configuration
Below is the default HOCON configuration for the base Akka.Remote package.
#####################################
# Akka Remote Reference Config File #
#####################################
# This is the reference config file that contains all the default settings.
# Make your edits/overrides in your application.conf.
# comments about akka.actor settings left out where they are already in akka-
# actor.jar, because otherwise they would be repeated in config rendering.
akka {
actor {
serialization-settings {
primitive {
# Resolves an edge-case issue introduced in Akka.NET v1.4.20
# Described here: https://getakka.net/community/whats-new/akkadotnet-v1.4-upgrade-advisories.html#upgrading-to-akkanet-v1426-from-older-versions
use-legacy-behavior = on
}
}
serializers {
akka-containers = "Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote"
akka-misc = "Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote"
primitive = "Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote"
proto = "Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote"
daemon-create = "Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote"
akka-system-msg = "Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote"
}
serialization-bindings {
"Akka.Actor.ActorSelectionMessage, Akka" = akka-containers
"Akka.Remote.DaemonMsgCreate, Akka.Remote" = daemon-create
"Google.Protobuf.IMessage, Google.Protobuf" = proto
"Akka.Actor.Identify, Akka" = akka-misc
"Akka.Actor.ActorIdentity, Akka" = akka-misc
"Akka.Actor.IActorRef, Akka" = akka-misc
"Akka.Actor.PoisonPill, Akka" = akka-misc
"Akka.Actor.Kill, Akka" = akka-misc
"Akka.Actor.PoisonPill, Akka" = akka-misc
"Akka.Actor.Status+Failure, Akka" = akka-misc
"Akka.Actor.Status+Success, Akka" = akka-misc
#"Akka.Actor.LocalScope, Akka" = akka-misc
"Akka.Actor.RemoteScope, Akka" = akka-misc
"Akka.Routing.FromConfig, Akka" = akka-misc
"Akka.Routing.DefaultResizer, Akka" = akka-misc
"Akka.Routing.RoundRobinPool, Akka" = akka-misc
"Akka.Routing.BroadcastPool, Akka" = akka-misc
"Akka.Routing.RandomPool, Akka" = akka-misc
"Akka.Routing.ScatterGatherFirstCompletedPool, Akka" = akka-misc
"Akka.Routing.TailChoppingPool, Akka" = akka-misc
"Akka.Routing.ConsistentHashingPool, Akka" = akka-misc
"Akka.Configuration.Config, Akka" = akka-misc
"Akka.Remote.RemoteWatcher+Heartbeat, Akka.Remote" = akka-misc
"Akka.Remote.RemoteWatcher+HeartbeatRsp, Akka.Remote" = akka-misc
"Akka.Remote.Routing.RemoteRouterConfig, Akka.Remote" = akka-misc
"Akka.Dispatch.SysMsg.SystemMessage, Akka" = akka-system-msg
"System.String" = primitive
"System.Int32" = primitive
"System.Int64" = primitive
}
serialization-identifiers {
"Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote" = 2
"Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote" = 3
"Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote" = 6
"Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote" = 16
"Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote" = 17
"Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote" = 22
}
deployment {
default {
# if this is set to a valid remote address, the named actor will be
# deployed at that node e.g. "akka.tcp://sys@host:port"
remote = ""
target {
# A list of hostnames and ports for instantiating the children of a
# router
# The format should be on "akka.tcp://sys@host:port", where:
# - sys is the remote actor system name
# - hostname can be either hostname or IP address the remote actor
# should connect to
# - port should be the port for the remote server on the other node
# The number of actor instances to be spawned is still taken from the
# nr-of-instances setting as for local routers; the instances will be
# distributed round-robin among the given nodes.
nodes = []
}
}
}
}
remote {
### General settings
# Timeout after which the startup of the remoting subsystem is considered
# to be failed. Increase this value if your transport drivers (see the
# enabled-transports section) need longer time to be loaded.
startup-timeout = 10 s
# Timout after which the graceful shutdown of the remoting subsystem is
# considered to be failed. After the timeout the remoting system is
# forcefully shut down. Increase this value if your transport drivers
# (see the enabled-transports section) need longer time to stop properly.
shutdown-timeout = 10 s
# Before shutting down the drivers, the remoting subsystem attempts to flush
# all pending writes. This setting controls the maximum time the remoting is
# willing to wait before moving on to shut down the drivers.
flush-wait-on-shutdown = 2 s
# Reuse inbound connections for outbound messages
use-passive-connections = on
# Controls the backoff interval after a refused write is reattempted.
# (Transports may refuse writes if their internal buffer is full)
backoff-interval = 0.05 s
# Acknowledgment timeout of management commands sent to the transport stack.
command-ack-timeout = 30 s
# The timeout for outbound associations to perform the handshake.
# If the transport is akka.remote.dot-netty.tcp or akka.remote.dot-netty.ssl
# the configured connection-timeout for the transport will be used instead.
handshake-timeout = 15 s
# If set to a nonempty string remoting will use the given dispatcher for
# its internal actors otherwise the default dispatcher is used. Please note
# that since remoting can load arbitrary 3rd party drivers (see
# "enabled-transport" and "adapters" entries) it is not guaranteed that
# every module will respect this setting.
use-dispatcher = "akka.remote.default-remote-dispatcher"
### Security settings
# Enable untrusted mode for full security of server managed actors, prevents
# system messages to be send by clients, e.g. messages like 'Create',
# 'Suspend', 'Resume', 'Terminate', 'Supervise', 'Link' etc.
untrusted-mode = off
# When 'untrusted-mode=on' inbound actor selections are by default discarded.
# Actors with paths defined in this white list are granted permission to receive actor
# selections messages.
# E.g. trusted-selection-paths = ["/user/receptionist", "/user/namingService"]
trusted-selection-paths = []
### Logging
# If this is "on", Akka will log all inbound messages at DEBUG level,
# if off then they are not logged
log-received-messages = off
# If this is "on", Akka will log all outbound messages at DEBUG level,
# if off then they are not logged
log-sent-messages = off
# Sets the log granularity level at which Akka logs remoting events. This setting
# can take the values OFF, ERROR, WARNING, INFO, DEBUG, or ON. For compatibility
# reasons the setting "on" will default to "debug" level. Please note that the effective
# logging level is still determined by the global logging level of the actor system:
# for example debug level remoting events will be only logged if the system
# is running with debug level logging.
# Failures to deserialize received messages also fall under this flag.
log-remote-lifecycle-events = on
# Logging of message types with payload size in bytes larger than
# this value. Maximum detected size per message type is logged once,
# with an increase threshold of 10%.
# By default this feature is turned off. Activate it by setting the property to
# a value in bytes, such as 1000b. Note that for all messages larger than this
# limit there will be extra performance and scalability cost.
log-frame-size-exceeding = off
# Log warning if the number of messages in the backoff buffer in the endpoint
# writer exceeds this limit. It can be disabled by setting the value to off.
log-buffer-size-exceeding = 50000
### Failure detection and recovery
# For TCP it is not important to have fast failure detection, since
# most connection failures are captured by TCP itself.
# The default DeadlineFailureDetector will trigger if there are no heartbeats within
# the duration heartbeat-interval + acceptable-heartbeat-pause, i.e. 20 seconds
# the duration heartbeat-interval + acceptable-heartbeat-pause, i.e. 124 seconds
transport-failure-detector {
# FQCN of the failure detector implementation.
# It must implement akka.remote.FailureDetector and have
# a public constructor with a com.typesafe.config.Config and
# akka.actor.EventStream parameter.
implementation-class = "Akka.Remote.DeadlineFailureDetector,Akka.Remote"
# How often keep-alive heartbeat messages should be sent to each connection.
heartbeat-interval = 4 s
# Number of potentially lost/delayed heartbeats that will be
# accepted before considering it to be an anomaly.
# This margin is important to be able to survive sudden, occasional,
# pauses in heartbeat arrivals, due to for example garbage collect or
# network drop.
acceptable-heartbeat-pause = 120 s
}
# Settings for the Phi accrual failure detector (http://ddg.jaist.ac.jp/pub/HDY+04.pdf
# [Hayashibara et al]) used for remote death watch.
watch-failure-detector {
# FQCN of the failure detector implementation.
# It must implement akka.remote.FailureDetector and have
# a public constructor with a com.typesafe.config.Config and
# akka.actor.EventStream parameter.
implementation-class = "Akka.Remote.PhiAccrualFailureDetector,Akka.Remote"
# How often keep-alive heartbeat messages should be sent to each connection.
heartbeat-interval = 1 s
# Defines the failure detector threshold.
# A low threshold is prone to generate many wrong suspicions but ensures
# a quick detection in the event of a real crash. Conversely, a high
# threshold generates fewer mistakes but needs more time to detect
# actual crashes.
threshold = 10.0
# Number of the samples of inter-heartbeat arrival times to adaptively
# calculate the failure timeout for connections.
max-sample-size = 200
# Minimum standard deviation to use for the normal distribution in
# AccrualFailureDetector. Too low standard deviation might result in
# too much sensitivity for sudden, but normal, deviations in heartbeat
# inter arrival times.
min-std-deviation = 100 ms
# Number of potentially lost/delayed heartbeats that will be
# accepted before considering it to be an anomaly.
# This margin is important to be able to survive sudden, occasional,
# pauses in heartbeat arrivals, due to for example garbage collect or
# network drop.
acceptable-heartbeat-pause = 10 s
# How often to check for nodes marked as unreachable by the failure
# detector
unreachable-nodes-reaper-interval = 1s
# After the heartbeat request has been sent the first failure detection
# will start after this period, even though no heartbeat mesage has
# been received.
expected-response-after = 1 s
}
# After failed to establish an outbound connection, the remoting will mark the
# address as failed. This configuration option controls how much time should
# be elapsed before reattempting a new connection. While the address is
# gated, all messages sent to the address are delivered to dead-letters.
# Since this setting limits the rate of reconnects setting it to a
# very short interval (i.e. less than a second) may result in a storm of
# reconnect attempts.
retry-gate-closed-for = 5 s
# After catastrophic communication failures that result in the loss of system
# messages or after the remote DeathWatch triggers the remote system gets
# quarantined to prevent inconsistent behavior.
# This setting controls how long the Quarantine marker will be kept around
# before being removed to avoid long-term memory leaks.
# WARNING: DO NOT change this to a small value to re-enable communication with
# quarantined nodes. Such feature is not supported and any behavior between
# the affected systems after lifting the quarantine is undefined.
prune-quarantine-marker-after = 5 d
# If system messages have been exchanged between two systems (i.e. remote death
# watch or remote deployment has been used) a remote system will be marked as
# quarantined after the two system has no active association, and no
# communication happens during the time configured here.
# The only purpose of this setting is to avoid storing system message redelivery
# data (sequence number state, etc.) for an undefined amount of time leading to long
# term memory leak. Instead, if a system has been gone for this period,
# or more exactly
# - there is no association between the two systems (TCP connection, if TCP transport is used)
# - neither side has been attempting to communicate with the other
# - there are no pending system messages to deliver
# for the amount of time configured here, the remote system will be quarantined and all state
# associated with it will be dropped.
quarantine-after-silence = 2 d
# This setting defines the maximum number of unacknowledged system messages
# allowed for a remote system. If this limit is reached the remote system is
# declared to be dead and its UID marked as tainted.
system-message-buffer-size = 20000
# This setting defines the maximum idle time after an individual
# acknowledgement for system messages is sent. System message delivery
# is guaranteed by explicit acknowledgement messages. These acks are
# piggybacked on ordinary traffic messages. If no traffic is detected
# during the time period configured here, the remoting will send out
# an individual ack.
system-message-ack-piggyback-timeout = 0.3 s
# This setting defines the time after internal management signals
# between actors (used for DeathWatch and supervision) that have not been
# explicitly acknowledged or negatively acknowledged are resent.
# Messages that were negatively acknowledged are always immediately
# resent.
resend-interval = 2 s
# Maximum number of unacknowledged system messages that will be resent
# each 'resend-interval'. If you watch many (> 1000) remote actors you can
# increase this value to for example 600, but a too large limit (e.g. 10000)
# may flood the connection and might cause false failure detection to trigger.
# Test such a configuration by watching all actors at the same time and stop
# all watched actors at the same time.
resend-limit = 200
# WARNING: this setting should not be not changed unless all of its consequences
# are properly understood which assumes experience with remoting internals
# or expert advice.
# This setting defines the time after redelivery attempts of internal management
# signals are stopped to a remote system that has been not confirmed to be alive by
# this system before.
initial-system-message-delivery-timeout = 3 m
### Transports and adapters
# List of the transport drivers that will be loaded by the remoting.
# A list of fully qualified config paths must be provided where
# the given configuration path contains a transport-class key
# pointing to an implementation class of the Transport interface.
# If multiple transports are provided, the address of the first
# one will be used as a default address.
enabled-transports = ["akka.remote.dot-netty.tcp"]
# Transport drivers can be augmented with adapters by adding their
# name to the applied-adapters setting in the configuration of a
# transport. The available adapters should be configured in this
# section by providing a name, and the fully qualified name of
# their corresponding implementation. The class given here
# must implement Akka.Remote.Transport.TransportAdapterProvider
# and have public constructor without parameters.
adapters {
gremlin = "Akka.Remote.Transport.FailureInjectorProvider,Akka.Remote"
trttl = "Akka.Remote.Transport.ThrottlerProvider,Akka.Remote"
}
### Default configuration for the DotNetty based transport drivers
dot-netty.tcp {
# The class given here must implement the akka.remote.transport.Transport
# interface and offer a public constructor which takes two arguments:
# 1) akka.actor.ExtendedActorSystem
# 2) com.typesafe.config.Config
transport-class = "Akka.Remote.Transport.DotNetty.TcpTransport,Akka.Remote"
# Transport drivers can be augmented with adapters by adding their
# name to the applied-adapters list. The last adapter in the
# list is the adapter immediately above the driver, while
# the first one is the top of the stack below the standard
# Akka protocol
applied-adapters = []
transport-protocol = tcp
# Byte order used for network communication. Event thou DotNetty is big-endian
# by default, we need to switch it back to little endian in order to support
# backward compatibility with Helios.
byte-order = "little-endian"
# The default remote server port clients should connect to.
# Default is 2552 (AKKA), use 0 if you want a random available port
# This port needs to be unique for each actor system on the same machine.
port = 2552
# Similar in spirit to "public-hostname" setting, this allows Akka.Remote users
# to alias the port they're listening on. The socket will actually listen on the
# "port" setting, but when connecting to other ActorSystems this node will advertise
# itself as being connected to the "public-port". This is helpful when working with
# hosting environments that rely on address translation and port-forwarding, such as Docker.
#
# Leave this setting to "0" if you don't intend to use it.
public-port = 0
# The hostname or ip to bind the remoting to,
# InetAddress.getLocalHost.getHostAddress is used if empty
hostname = ""
# If this value is set, this becomes the public address for the actor system on this
# transport, which might be different than the physical ip address (hostname)
# this is designed to make it easy to support private / public addressing schemes
public-hostname = ""
# If set to true, we will use IPV6 addresses upon DNS resolution for host names.
# Otherwise, we will use IPV4.
dns-use-ipv6 = false
# If set to true, we will enforce usage of IPV4 or IPV6 addresses upon DNS resolution for host names.
# If dns-use-ipv6 = true, we will use IPV6 enforcement
# Otherwise, we will use IPV4.
# Warning: when ip family is enforced, any connection between IPV4 and IPV6 is impossible
#
# enforce-ip-family setting is used only in some special cases, when default behaviour of
# underlying sockets leads to errors. Typically this occurs when an environment doesn't support
# IPV6 or dual-mode sockets.
# As of 09/21/2016 there are two known cases: running under Mono and in Azure WebApp
# for them we will need enforce-ip-family = true, and for Azure dns-use-ipv6 = false
# This property is always set to true if Mono runtime is detected.
enforce-ip-family = false
# Enables SSL support on this transport
enable-ssl = false
# Enables backwards compatibility with Akka.Remote clients running Helios 1.*
enable-backwards-compatibility = false
# Sets the connectTimeoutMillis of all outbound connections,
# i.e. how long a connect may take until it is timed out
connection-timeout = 15 s
# PERFORMANCE TUNING
#
# The batching feature of DotNetty is designed to help batch together logical writes into a smaller
# number of physical writes across the socket. This helps significantly reduce the number of system calls
# and can improve performance by as much as 150% on some systems when enabled.
batching{
# Enables the batching system. When disabled, every write will be flushed immediately.
# Disable this setting if you're working with a VERY low-traffic system that requires
# fast (< 40ms) acknowledgement for all periodic messages.
enabled = true
# The maximum number of explicit flushes that will be allowed before being batched.
# Batching normally happens when the channel switches from writes to reads and self-tunes automatically.
max-pending-writes = 30
}
# If set to "<id.of.dispatcher>" then the specified dispatcher
# will be used to accept inbound connections, and perform IO. If "" then
# dedicated threads will be used.
# Please note that the Helios driver only uses this configuration and does
# not read the "akka.remote.use-dispatcher" entry. Instead it has to be
# configured manually to point to the same dispatcher if needed.
use-dispatcher-for-io = ""
# Sets the high water mark for the in and outbound sockets,
# set to 0b for platform default
write-buffer-high-water-mark = 0b
# Sets the low water mark for the in and outbound sockets,
# set to 0b for platform default
write-buffer-low-water-mark = 0b
# Sets the send buffer size of the Sockets,
# set to 0b for platform default
send-buffer-size = 256000b
# Sets the receive buffer size of the Sockets,
# set to 0b for platform default
receive-buffer-size = 256000b
# Maximum message size the transport will accept, but at least
# 32000 bytes.
# Please note that UDP does not support arbitrary large datagrams,
# so this setting has to be chosen carefully when using UDP.
# Both send-buffer-size and receive-buffer-size settings has to
# be adjusted to be able to buffer messages of maximum size.
maximum-frame-size = 128000b
# Sets the size of the connection backlog
backlog = 4096
# Enables the TCP_NODELAY flag, i.e. disables Nagle's algorithm
tcp-nodelay = on
# Enables TCP Keepalive, subject to the O/S kernel's configuration
tcp-keepalive = on
# Enables SO_REUSEADDR, which determines when an ActorSystem can open
# the specified listen port (the meaning differs between *nix and Windows)
# Valid values are "on", "off", and "off-for-windows"
# due to the following Windows bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4476378
# "off-for-windows" of course means that it's "on" for all other platforms
tcp-reuse-addr = off-for-windows
# Used to configure the number of I/O worker threads on server sockets
server-socket-worker-pool {
# Min number of threads to cap factor-based number to
pool-size-min = 2
# The pool size factor is used to determine thread pool size
# using the following formula: ceil(available processors * factor).
# Resulting size is then bounded by the pool-size-min and
# pool-size-max values.
pool-size-factor = 1.0
# Max number of threads to cap factor-based number to
pool-size-max = 2
}
# Used to configure the number of I/O worker threads on client sockets
client-socket-worker-pool {
# Min number of threads to cap factor-based number to
pool-size-min = 2
# The pool size factor is used to determine thread pool size
# using the following formula: ceil(available processors * factor).
# Resulting size is then bounded by the pool-size-min and
# pool-size-max values.
pool-size-factor = 1.0
# Max number of threads to cap factor-based number to
pool-size-max = 2
}
ssl {
certificate {
# Valid certificate path required
path = ""
# Valid certificate password required
password = ""
# Default key storage flag is "default-key-set"
# Available flags include:
# default-key-set | exportable | machine-key-set | persist-key-set | user-key-set | user-protected
# flags = [ "default-key-set" ]
# To use a Thumbprint instead of a file, set this to true
# And specify a thumbprint and it's storage location below
use-thumbprint-over-file = false
# Valid Thumbprint required (if use-thumbprint-over-file is true)
# A typical thumbprint is a format similar to: "45df32e258c92a7abf6c112e54912ab15bbb9eb0"
# On Windows machines, The thumbprint for an installed certificate can be located
# By using certlm.msc and opening the certificate under the 'Details' tab.
thumbprint = ""
# The Store name. Under windows The most common option is "My", which indicates the personal store.
# See System.Security.Cryptography.X509Certificates.StoreName for other common values.
store-name = ""
# Valid options : local-machine or current-user
# current-user indicates a certificate stored under the user's account
# local-machine indicates a certificate stored at an operating system level (potentially shared by users)
store-location = "current-user"
}
suppress-validation = false
}
}
dot-netty.udp = ${akka.remote.dot-netty.tcp}
dot-netty.udp {
transport-protocol = udp
}
### Default configuration for the failure injector transport adapter
gremlin {
# Enable debug logging of the failure injector transport adapter
debug = off
}
### Default dispatcher for the remoting subsystem
default-remote-dispatcher {
executor = default-executor
fork-join-executor {
parallelism-min = 2
parallelism-factor = 0.5
parallelism-max = 16
}
channel-executor.priority = "high"
}
backoff-remote-dispatcher {
executor = default-executor
fork-join-executor {
parallelism-min = 2
parallelism-max = 2
}
channel-executor.priority = "low"
}
}
}
Improve this Doc