Dot Net Quickstart

In this tutorial, we will show you how to integrate Permit.io with your application in just a few simple steps.

Setup your PDP (Policy Decision Point) Container

We provide you with a Policy-Decision-Point - aka an authorization microservice, as a container for you to use. Please follow the steps below to install and run the container on your local machine.

1. Pull our PDP container from Docker Hub

If you do not have Docker installed as of yet, click here to install Docker.

docker pull permitio/pdp-v2:latest

2. Get the Permit.io API key

Navigate to the Project Management page with the Permit.io web interface. Find the active environment that is marked with a green dot on the icon. Copy the Secret Key.

Alternatively, while anyhwere on the Permit.io web interface, click on your user icon in the top right of the screen, and "Copy SDK Secret Key" from there.

3. Run the container

Remember to replace <YOUR_API_KEY> with the Secret Key you have just obtained in the previous step.

docker run -p 7766:7000 --env PDP_API_KEY=<YOUR_API_KEY> permitio/pdp-v2:latest

info

Congratulations! You should now have a PDP container running. You can always check the status of the container by typing docker ps in your terminal.

Let's now add the Permit SDK to your app or use the following demo example below.

Add the SDK to your .NET code

We are now ready to init the .NET SDK and check for permissions.

1. Create a new directory with an empty .NET project inside (we use HttpListener to demonstrate a REST API).

mkdir hello-permissions-dotnet && cd hello-permissions-dotnet && dotnet new console

1. Install the Permit.io SDK

dotnet add package Permit --version 0.4.0-rc

2. Import the SDK into your code

using PermitSDK;
using PermitSDK.Models;

3. Create a new instance of the SDK.
   You can find instructions on getting a secret API key in the previous section.

// This line initializes the SDK and connects your .NET app
// to the Permit.io PDP container you've set up in the previous step.
Permit permit = new Permit(
    "[YOUR_API_KEY]",
    "http://localhost:7766"
);

Check for permissions using the API

bool permitted = await permit.Check(user.key, "create", "document");
if (permitted)
{
  Console.Write("User is PERMITTED to create a document");
}
else
{
  Console.Write("User is NOT PERMITTED to create a document");
}

Full app example

Assuming a .NET app made up of a single file, with the Permit modules installed.

using System;
using System.Text;
using System.Net;
using System.Threading.Tasks;
using PermitSDK;
using PermitSDK.Models;

namespace PermitOnboardingApp
{
    class HttpServer
    {
        public static HttpListener listener;
        public static string url = "http://localhost:4000/";
        public static string pageData ="<p>User {0} is {1} to {2} {3}</p>";
        public static async Task HandleIncomingConnections()
        {
            bool runServer = true;
            while (runServer)
            {
                HttpListenerContext ctx = await listener.GetContextAsync();
                HttpListenerResponse resp = ctx.Response;

                // in a real app, you would typically decode the user id from a JWT token
                UserKey user = new UserKey("userId", "John", "Smith", "john@permit.io");
                // init Permit SDK
                string clientToken = "[YOUR_API_KEY]";
                Permit permit = new Permit(
                    clientToken,
                    "http://localhost:7766",
                    "default",
                    true
                );
                // After we created this user in the previous step, we also synced the user's identifier
                // to permit.io servers with permit.write(permit.api.syncUser(user)). The user identifier
                // can be anything (email, db id, etc) but must be unique for each user. Now that the
                // user is synced, we can use its identifier to check permissions with `permit.check()`.
                bool permitted = await permit.Check(user.key, "create", "task");
                if (permitted)
                {
                    await SendResponseAsync(resp, 200, String.Format(pageData, user.firstName + user.lastName, "Permitted", "create", "task"));
                }
                else
                {
                    await SendResponseAsync(resp, 403, String.Format(pageData, user.firstName + user.lastName, "NOT Permitted", "create", "task"));
                }

            }
        }
        public static async Task SendResponseAsync(HttpListenerResponse resp, int returnCode, string responseContent)
        {
            byte[] data = Encoding.UTF8.GetBytes(responseContent);
            resp.StatusCode = returnCode;
            await resp.OutputStream.WriteAsync(data, 0, data.Length);
            resp.Close();
        }

        public static void Main(string[] args)
        {
            // Create a Http server and start listening for incoming connections
            listener = new HttpListener();
            listener.Prefixes.Add(url);
            listener.Start();
            Console.WriteLine("Listening for connections on {0}", url);
            Task listenTask = HandleIncomingConnections();
            listenTask.GetAwaiter().GetResult();
            listener.Close();
        }
    }
}

Now that your application is ready, let's run it:

dotnet run

Finally, go to http://localhost:4000 to see the outcome of the permission check.