Please support https://github.com/G-Research/consuldotnet , this repo is no longer maintained

Consul.NET

Fork from https://github.com/PlayFab/consuldotnet and Support GRPC.

• Consul API: v0.7.2
• .NET Core: >= 2.0

Consul.NET is a .NET port of the Go Consul API, but reworked to use .NET
idioms such as Tasks/CancellationTokens instead of Goroutines/Channels.
The majority of the calls directly track the HTTP
API, but this API does have
additional functionality that is provided in the Go API, like Locks and
Semaphores.

GRPC Check Example

var consulClient = new ConsulClient(x => x.Address = new Uri($"http://localhost:8500"));
var grpCheck = new AgentServiceCheck()
{
    DeregisterCriticalServiceAfter = TimeSpan.FromSeconds(5),
    Interval = TimeSpan.FromSeconds(10),
    GRPC = "127.0.0.1:5000",
    GRPCUseTLS = false,
    Timeout = TimeSpan.FromSeconds(10)
};
var registration = new AgentServiceRegistration()
{
    Checks = new[] { grpCheck },
    ID = Guid.NewGuid().ToString(),
    Name = "grpctest",
    Address = "localhost",
    Port = 5000,
    Tags = new[] { $"xc/grpc/test" }
};
await consulClient.Agent.ServiceRegister(registration);

ASP.NET Core

services.AddConsul("http://localhost:8500")
    .AddGRPCHealthCheck("localhost:5000")
    .RegisterService("grpctest","localhost",5000,new []{"xc/grpc/test"});

Example

You’ll need a running Consul Server on your local machine, or a Consul
Agent connected to a Consul Server cluster. To run a local server:

1. Download a copy of the latest Windows
   version and unzip it into the Consul.Test folder.
2. Open a command prompt and cd to the Consul.Test folder.
3. Run .\consul.exe agent -dev -config-file test_config.json

This creates a 1-server cluster that operates in “dev” mode (does not
write data to disk) and listens on 127.0.0.1:8500.

Once Consul is running (you’ll see something like consul: cluster leadership acquired) in your command prompt, then do the following
steps in your project.

Add a reference to the Consul library and add a using statement:

using Consul;

Write a function to talk to the KV store:

public static async Task<string> HelloConsul()
{
    using (var client = new ConsulClient())
    {
        var putPair = new KVPair("hello")
        {
            Value = Encoding.UTF8.GetBytes("Hello Consul")
        };
        var putAttempt = await client.KV.Put(putPair);
        if (putAttempt.Response)
        {
            var getPair = await client.KV.Get("hello");
            return Encoding.UTF8.GetString(getPair.Response.Value, 0,
                getPair.Response.Value.Length);
        }
        return "";
    }
}

And call it:

Console.WriteLine(HelloConsul().GetAwaiter().GetResult());

You should see Hello Consul in the output of your program. You should
also see the following lines in your command prompt, if you’re running
a local Consul server:

[DEBUG] http: Request /v1/kv/hello (6.0039ms)
[DEBUG] http: Request /v1/kv/hello (0)

The API just went out to Consul, wrote “Hello Consul” under the key
“hello”, then fetched the data back out and wrote it to your prompt.

Usage

All operations are done using a ConsulClient object. First,
instantiate a ConsulClient object, which connects to localhost:8500,
the default Consul HTTP API port. Once you’ve got a ConsulClient
object, various functionality is exposed as properties under the
ConsulClient.

All responses are wrapped in QueryResponse and WriteResponse
classes, which provide metadata about the request, like how long it
took and the monotonic Consul index when the operation occured.

This API also assumes some knowledge of Consul, including things like
blocking queries and consistency
modes

ACL

The ACL endpoints are used to create, update, destroy, and query ACL tokens.

Agent

The Agent endpoints are used to interact with the local Consul agent.
Usually, services and checks are registered with an agent which then
takes on the burden of keeping that data synchronized with the cluster.
For example, the agent registers services and checks with the Catalog
and performs anti-entropy to recover from outages.

Catalog

The Catalog is the endpoint used to register and deregister nodes,
services, and checks. It also provides query endpoints.

Event

The Event endpoints are used to fire new events and to query the
available events.

Health

The Health endpoints are used to query health-related information. They
are provided separately from the Catalog since users may prefer not to
use the optional health checking mechanisms. Additionally, some of the
query results from the Health endpoints are filtered while the Catalog
endpoints provide the raw entries.

KV

The KV endpoint is used to access Consul’s simple key/value store,
useful for storing service configuration or other metadata.

Query

The Prepared Query endpoints are used to create, update, destroy, and
execute prepared queries. Prepared queries allow you to register a
complex service query and then execute it later via its ID or name to
get a set of healthy nodes that provide a given service.

Session

The Session endpoints are used to create, destroy, and query sessions.

Status

The Status endpoints are used to get information about the status of the
Consul cluster. This information is generally very low level and not
often useful for clients.

Additional Functions

Functionality based on the Consul guides using the available primitives
has been implemented as well, just like the Go API.

Lock

Lock is used to implement client-side leader election for a distributed
lock. It is an implementation of the Consul Leader
Election guide.

Semaphore

Semaphore is used to implement a distributed semaphore using the Consul
KV primitives. It is an implementation of the Consul Semaphore guide.

Using with .NET Core and Mono

Both .NET 4.5+ and .NET Core 1.0+ are fully supported. Mono is supported on a
best-effort basis. It should compile and run happily on Mono but this is not as
heavily tested as Microsoft .NET stacks. If you have any issues using the Nuget
package or compiling this code with .NET, .NET Core, or Mono, please file a
Github issue with details of the problem.