The name NATS is often described as deriving from “Neural Autonomic Transport System”, reflecting the idea of a communications fabric acting as the nervous system of a distributed application. It should not be confused with NAT (Network Address Translation), which solves an entirely different networking problem and was covered in part 5 of this series.

Moving to virtualized environments and datacenters requires broadcasters to think completely differently about their infrastructures. To achieve the flexibility, scalability, and resilience that cloud computing promises, whether public or private, requires software to be written with virtualization in mind from the outset, not as an afterthought.

Virtualization has led to the development of software disciplines such as microservices working in containers. This is a complete change from the huge monolithic codebase of previous years where scalability often relied on supplying ever larger servers. The beauty of microservices is that they can be deployed horizontally; that is, more servers of moderate power are deployed as opposed to a few huge servers, thus simplifying scalability.

Microservice Communications

For monolithic code, functions resided within the same compilation so exchanging data between them was relatively straightforward. However, as we move more to microservices and the philosophy of thinking they promote, programs must now communicate with each other outside of their codebase and often on entirely different domains. In essence, each microservice works in isolation but must still communicate with its counterparts.

One messaging solution is to use REST API communications. These are software interfaces that use HTTP messages such as GET and POST to exchange data. Although this is a well-proven technology and is used extensively, it tends to have limitations for scaling. For example, a resource-monitoring microservice may be requesting monitoring data from a single transcoder every second. This is easily achievable with REST APIs. If the number of transcoder-microservice instances increases to one hundred or one thousand, however, REST APIs can become less efficient as large numbers of services repeatedly poll for state changes, particularly in highly distributed cloud environments.

NATS messaging solves this type of scenario by using an advanced type of messaging system based on the client server model. It’s open source, scales well, and provides secure channels with the option of user client authentication.

Simple Messaging

In its simplest deployment, a NATS system will consist of two clients and a NATS server. A client will publish messages and other clients known as subscribers will listen and opt in to receive them. This gives the potential of one-to-many broadcast type messaging, as well as querying.

The monitoring service publishes a request on a defined subject. Services interested in that subject receive the message and can respond through the NATS infrastructure.

Messages may also be point-to-point or many-to-one, as used when sending the transcoder monitoring data back to the monitoring microservice. But key to this deployment is the ability to both secure the communication channel and scale the system using the distributed resource mindset.

Message Scaling And Resilience

NATS is a middleware deployment, which means it is independent of the underlying hardware infrastructure. This is particularly useful when scaling systems: new NATS servers can be easily deployed within a virtualized environment as it is lightweight and compact in terms of its resource utilization (see Figure 1).

To improve resilience and scalability, NATS servers are clustered to provide main and backup systems as well as extra resource. A cluster of three NATS servers may operate as peers, sharing client connections and providing resilience should an individual server fail.

Also, several clusters of NATS servers could be connected but geographically dispersed. For example, three clusters could be configured: one in Europe, one in US West Coast and one in US East Coast. Not only does this method provide local redundancy, it also provides scalable resources using virtualized servers that can be spun up and down at will.

It’s important to note that the NATS system is a message exchange method and not necessarily designed to shift large amounts of video and audio data. It is possible to achieve this, but a far better use of resources is for the microservice to read and write the media data directly to and from the storage servers. The relevant messages will be exchanged between the software applications connected to the NATS servers to provide location information for the media storage.

A Broadcast Workflow Example

A useful way to understand NATS is to consider a cloud playout system. In a traditional architecture, a scheduling application may need direct connections to graphics engines, compliance recording systems, monitoring platforms, subtitle generators, and transcoding services.  As the number of applications grows, the complexity of maintaining these point-to-point integrations can increase significantly.

Using NATS, the scheduling service simply publishes a message indicating that a program is due to start. The message is sent to a predefined subject that is monitored by the relevant services. A graphics application may respond by loading the required branding assets, while a compliance recorder begins capturing the output stream. At the same time, subtitle generation services can prepare the appropriate language tracks, monitoring systems can verify service availability, and transcoders can allocate processing resources for the program.

Importantly, each service operates independently and does not need direct knowledge of the other applications in the workflow. New services can be added without modifying existing software, provided they subscribe to the appropriate subjects. This decoupled architecture improves scalability and resilience while simplifying system design. As cloud-based broadcast workflows continue to grow in complexity, messaging systems such as NATS provide an efficient mechanism for coordinating large numbers of distributed microservices.

Keeping Messages Secure

As discussed in previous articles, mechanisms such as TLS and token-based authentication form the foundation of modern zero-trust architectures.  NATS integrates naturally with these approaches, allowing messages to be encrypted, authenticated, and authorized while maintaining the scalability required by modern cloud-native broadcast systems.

Security is at the core of NATS and message connections can be encrypted with TLS. Also, client connections can be authenticated in several ways including Token Authentication, username/password credentials and TLS certification.

Authorization tokens are the equivalent of a stamped ticket to an event and are created when a user verifies their credentials. Once this is done, the token is used to access servers, storage, applications, and APIs, thus freeing the user from logging in each time they need to access a particular service.

A centralized administration resource creates unique tokens based on a user’s login credentials with the appropriate read/write access. This is particularly useful for services exchanging messages between APIs as the token is sent with the message, allowing the receiving service to verify the request and provide the appropriate access.

NATS advanced messaging has been developed to simultaneously solve the challenges of allowing software applications to securely exchange messages while achieving scalability, flexibility, and resilience.