Search Results for

    Show / Hide Table of Contents

    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.IntentionalRestart, 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"
        }
      }
    }
    
    In this article
    • githubEdit this page
    Back to top
    Contribute
    • Project Chat
    • Discussion Forum
    • Source Code
    Support
    • Akka.NET Support Plans
    • Akka.NET Observability Tools
    • Akka.NET Training & Consulting
    Maintained By
    • Petabridge - The Akka.NET Company
    • Learn Akka.NET