Mastering Tars: Deploy, Manage, and Monitor a High‑Performance Microservice Framework

What is Tars

Tars is a multi‑language embedded service governance framework that integrates development, operations, and testing into a complete solution. It offers extensible protocol encoding/decoding, high‑performance RPC, name routing and discovery, publishing monitoring, log statistics, and configuration management, enabling rapid construction of highly available distributed applications based on service‑mesh principles.

Tars Framework Source Deployment

Note: The instructions assume a CentOS 7 environment; CentOS 6 requires a glibc upgrade.

Deployment Environments

Docker environment installation

MySQL installation

Linux/Mac source deployment

Windows source deployment

Tars Docker deployment

K8s Docker deployment

Tars Node deployment

Dependency Requirements

Software

Version Requirement

Linux kernel

2.6.18 or newer

gcc

4.8.2 or newer, plus glibc‑devel

bison

2.5 or newer

flex

2.5 or newer

cmake

3.2 or newer

MySQL

4.1.17 or newer

nvm

0.35.1 or newer (installed automatically for the web UI)

node

12.13.0 or newer (installed automatically for the web UI)

Tars Service Deployment Management

Full‑life‑cycle page interaction during deployment

Zero‑configuration or template‑based deployment via the UI

Post‑deployment verification and real‑time status/log viewing

Version management with visual upgrade/downgrade

Remote deployment across VPN or public networks

Simple, non‑technical operation

Cross‑platform deployment support

Service Publishing Architecture

tars‑patch component uploads WAR packages to /usr/local/app/patch/tars.upload/ The Tars registry notifies nodes to pull the package locally

Service is started

Web UI shows startup status and streaming logs

Gray Release

Tars supports gray (canary) releases; see the accompanying diagram.

Circuit‑Breaker Strategy

Clients retrieve routing information from the registry; based on health checks, the registry can exclude faulty nodes, and clients can also perform active shielding when repeated timeouts are detected.

Service Publishing Comparison

Comparison Item

Tars Service Publishing

Traditional Service Publishing

Service Publishing

Visual UI, click‑through operation

SSH login, file upload, script execution

Service Upgrade

Upload WAR via UI and publish

Same flow but requires manual backup handling

Service Downgrade

Select version in UI and publish

Restore from backup or rebuild from source

Skill Requirement

None

Requires ops experience, shell scripting

Cluster Publishing

Select multiple nodes in UI

Copy package to each machine and restart manually

Tars Configuration Center

The configuration center provides unified management of service configuration files, supporting real‑time updates, push to services, and pull by services. Key benefits include centralized management, version history with rollback, simple retrieval via API, and hierarchical configuration levels (application, set, service, node).

Configuration Data Maintenance

Tars stores configuration metadata in two MySQL tables: t_config_files (file name, type, service, set, node IP, index ID) and t_config_references (reference relationships between configuration IDs).

Service Configuration

Through the Tars web UI, users can add configurations, create references, and push files to services; the files are then placed in the appropriate directories on the target nodes.

Tars Service Discovery

Tars uses an Interface Description Language (IDL) to define binary, extensible, cross‑language RPC protocols. The name service registers providers and enables consumers to discover service endpoints, supporting load‑balancing strategies and both automatic and manual addressing.

Calling Modes

Synchronous call – client waits for a response.

Asynchronous call – client proceeds while a callback handles the response.

One‑way call – client sends request without expecting a response.

Service Registration Advantages

Transparent and easy for developers

High availability – failure of a few registries does not affect the whole system

Prefer same‑datacenter nodes to reduce latency

Cross‑language support for microservices

Multiple load‑balancing algorithms (round‑robin, hash, weight, etc.)

Fault tolerance via name‑service exclusion and client‑side shielding

Tars Remote Logging

TarsLog is built on Logback, providing local and remote logging, log‑chain tracing, and log coloring. It supports high availability and can be integrated with Kafka for centralized log collection.

Log Printing Workflow

Download source from https://github.com/TarsCloud/TarsJava Package tars-plugins with mvn package Include the generated JAR in your project

Configure logback.xml with an appropriate appender

Obtain a logger via LoggerFactory.getLogger("root") Use logger.debug("message") to emit logs to the configured server

MDC Log Chain Tracing

MDC holds a ThreadLocal map; developers put a traceId into MDC, and the log pattern extracts it, enabling end‑to‑end request tracing.

Log Coloring

Implement a custom ForegroundCompositeConverterBase to define coloring rules, then reference the rule in logback.xml.

Logback Integration with Kafka

Method 1 – Custom Appender

Write a custom appender that sends logs to Kafka and configure it in logback.xml.

Method 2 – Open‑Source Kafka Appender

Add the dependency

<dependency>
  <groupId>com.github.danielwegener</groupId>
  <artifactId>logback-kafka-appender</artifactId>
  <version>0.2.0</version>
  <scope>runtime</scope>
</dependency>

and configure the Kafka appender in logback.xml (e.g.,

<root level="INFO"><appender-ref ref="kafkaAppender"/></root>

).

Monitoring and Statistics

Tars reports various metrics such as request count, latency, exceptions, and custom attributes (e.g., memory usage, queue size, cache hit rate). Statistics are aggregated by the SDK and reported to tarsstat at configurable intervals (default 1 minute).

Feature Monitoring

Feature monitors report custom key‑value pairs defined by the SDK (e.g., jvm.memory, jvm.gc) and can be extended programmatically.

Service Health Monitoring

Node services periodically poll managed services and report heartbeat status.

SDK heartbeats are checked for timeout.

Process existence is verified regularly.

Conclusion

The Tars framework offers a comprehensive suite for building, deploying, discovering, configuring, logging, and monitoring microservices, providing visual management, zero‑configuration deployment, high availability, and extensibility for modern backend development.