Authentication and permissions¶
Datasette does not require authentication by default. Any visitor to a Datasette instance can explore the full data and execute read-only SQL queries.
Datasette's plugin system can be used to add many different styles of authentication, such as user accounts, single sign-on or API keys.
Actors¶
Through plugins, Datasette can support both authenticated users (with cookies) and authenticated API agents (via authentication tokens). The word "actor" is used to cover both of these cases.
Every request to Datasette has an associated actor value, available in the code as request.actor
. This can be None
for unauthenticated requests, or a JSON compatible Python dictionary for authenticated users or API agents.
The actor dictionary can be any shape - the design of that data structure is left up to the plugins. A useful convention is to include an "id"
string, as demonstrated by the "root" actor below.
Plugins can use the actor_from_request(datasette, request) hook to implement custom logic for authenticating an actor based on the incoming HTTP request.
Using the "root" actor¶
Datasette currently leaves almost all forms of authentication to plugins - datasette-auth-github for example.
The one exception is the "root" account, which you can sign into while using Datasette on your local machine. This provides access to a small number of debugging features.
To sign in as root, start Datasette using the --root
command-line option, like this:
$ datasette --root
http://127.0.0.1:8001/-/auth-token?token=786fc524e0199d70dc9a581d851f466244e114ca92f33aa3b42a139e9388daa7
INFO: Started server process [25801]
INFO: Waiting for application startup.
INFO: Application startup complete.
INFO: Uvicorn running on http://127.0.0.1:8001 (Press CTRL+C to quit)
The URL on the first line includes a one-use token which can be used to sign in as the "root" actor in your browser. Click on that link and then visit http://127.0.0.1:8001/-/actor
to confirm that you are authenticated as an actor that looks like this:
{
"id": "root"
}
Permissions¶
Datasette has an extensive permissions system built-in, which can be further extended and customized by plugins.
The key question the permissions system answers is this:
Is this actor allowed to perform this action, optionally against this particular resource?
Actors are described above.
An action is a string describing the action the actor would like to perform. A full list is provided below - examples include view-table
and execute-sql
.
A resource is the item the actor wishes to interact with - for example a specific database or table. Some actions, such as permissions-debug
, are not associated with a particular resource.
Datasette's built-in view permissions (view-database
, view-table
etc) default to allow - unless you configure additional permission rules unauthenticated users will be allowed to access content.
Permissions with potentially harmful effects should default to deny. Plugin authors should account for this when designing new plugins - for example, the datasette-upload-csvs plugin defaults to deny so that installations don't accidentally allow unauthenticated users to create new tables by uploading a CSV file.
Defining permissions with "allow" blocks¶
The standard way to define permissions in Datasette is to use an "allow"
block. This is a JSON document describing which actors are allowed to perform a permission.
The most basic form of allow block is this (allow demo, deny demo):
{
"allow": {
"id": "root"
}
}
This will match any actors with an "id"
property of "root"
- for example, an actor that looks like this:
{
"id": "root",
"name": "Root User"
}
An allow block can specify "deny all" using false
(demo):
{
"allow": false
}
An "allow"
of true
allows all access (demo):
{
"allow": true
}
Allow keys can provide a list of values. These will match any actor that has any of those values (allow demo, deny demo):
{
"allow": {
"id": ["simon", "cleopaws"]
}
}
This will match any actor with an "id"
of either "simon"
or "cleopaws"
.
Actors can have properties that feature a list of values. These will be matched against the list of values in an allow block. Consider the following actor:
{
"id": "simon",
"roles": ["staff", "developer"]
}
This allow block will provide access to any actor that has "developer"
as one of their roles (allow demo, deny demo):
{
"allow": {
"roles": ["developer"]
}
}
Note that "roles" is not a concept that is baked into Datasette - it's a convention that plugins can choose to implement and act on.
If you want to provide access to any actor with a value for a specific key, use "*"
. For example, to match any logged-in user specify the following (allow demo, deny demo):
{
"allow": {
"id": "*"
}
}
You can specify that only unauthenticated actors (from anynomous HTTP requests) should be allowed access using the special "unauthenticated": true
key in an allow block (allow demo, deny demo):
{
"allow": {
"unauthenticated": true
}
}
Allow keys act as an "or" mechanism. An actor will be able to execute the query if any of their JSON properties match any of the values in the corresponding lists in the allow
block. The following block will allow users with either a role
of "ops"
OR users who have an id
of "simon"
or "cleopaws"
:
{
"allow": {
"id": ["simon", "cleopaws"],
"role": "ops"
}
}
Demo for cleopaws, demo for ops role, demo for an actor matching neither rule.
The /-/allow-debug tool¶
The /-/allow-debug
tool lets you try out different "action"
blocks against different "actor"
JSON objects. You can try that out here: https://latest.datasette.io/-/allow-debug
Configuring permissions in metadata.json¶
You can limit who is allowed to view different parts of your Datasette instance using "allow"
keys in your Metadata configuration.
You can control the following:
Access to the entire Datasette instance
Access to specific databases
Access to specific tables and views
Access to specific Canned queries
If a user cannot access a specific database, they will not be able to access tables, views or queries within that database. If a user cannot access the instance they will not be able to access any of the databases, tables, views or queries.
Controlling access to an instance¶
Here's how to restrict access to your entire Datasette instance to just the "id": "root"
user:
{
"title": "My private Datasette instance",
"allow": {
"id": "root"
}
}
To deny access to all users, you can use "allow": false
:
{
"title": "My entirely inaccessible instance",
"allow": false
}
One reason to do this is if you are using a Datasette plugin - such as datasette-permissions-sql - to control permissions instead.
Controlling access to specific databases¶
To limit access to a specific private.db
database to just authenticated users, use the "allow"
block like this:
{
"databases": {
"private": {
"allow": {
"id": "*"
}
}
}
}
Controlling access to specific tables and views¶
To limit access to the users
table in your bakery.db
database:
{
"databases": {
"bakery": {
"tables": {
"users": {
"allow": {
"id": "*"
}
}
}
}
}
}
This works for SQL views as well - you can list their names in the "tables"
block above in the same way as regular tables.
Warning
Restricting access to tables and views in this way will NOT prevent users from querying them using arbitrary SQL queries, like this for example.
If you are restricting access to specific tables you should also use the "allow_sql"
block to prevent users from bypassing the limit with their own SQL queries - see Controlling the ability to execute arbitrary SQL.
Controlling access to specific canned queries¶
Canned queries allow you to configure named SQL queries in your metadata.json
that can be executed by users. These queries can be set up to both read and write to the database, so controlling who can execute them can be important.
To limit access to the add_name
canned query in your dogs.db
database to just the root user:
{
"databases": {
"dogs": {
"queries": {
"add_name": {
"sql": "INSERT INTO names (name) VALUES (:name)",
"write": true,
"allow": {
"id": ["root"]
}
}
}
}
}
}
Controlling the ability to execute arbitrary SQL¶
Datasette defaults to allowing any site visitor to execute their own custom SQL queries, for example using the form on the database page or by appending a ?_where=
parameter to the table page like this.
Access to this ability is controlled by the execute-sql permission.
The easiest way to disable arbitrary SQL queries is using the default_allow_sql setting when you first start Datasette running.
You can alternatively use an "allow_sql"
block to control who is allowed to execute arbitrary SQL queries.
To prevent any user from executing arbitrary SQL queries, use this:
{
"allow_sql": false
}
To enable just the root user to execute SQL for all databases in your instance, use the following:
{
"allow_sql": {
"id": "root"
}
}
To limit this ability for just one specific database, use this:
{
"databases": {
"mydatabase": {
"allow_sql": {
"id": "root"
}
}
}
}
Checking permissions in plugins¶
Datasette plugins can check if an actor has permission to perform an action using the datasette.permission_allowed(...) method.
Datasette core performs a number of permission checks, documented below. Plugins can implement the permission_allowed(datasette, actor, action, resource) plugin hook to participate in decisions about whether an actor should be able to perform a specified action.
actor_matches_allow()¶
Plugins that wish to implement this same "allow"
block permissions scheme can take advantage of the datasette.utils.actor_matches_allow(actor, allow)
function:
from datasette.utils import actor_matches_allow
actor_matches_allow({"id": "root"}, {"id": "*"})
# returns True
The currently authenticated actor is made available to plugins as request.actor
.
The permissions debug tool¶
The debug tool at /-/permissions
is only available to the authenticated root user (or any actor granted the permissions-debug
action according to a plugin).
It shows the thirty most recent permission checks that have been carried out by the Datasette instance.
This is designed to help administrators and plugin authors understand exactly how permission checks are being carried out, in order to effectively configure Datasette's permission system.
Built-in permissions¶
This section lists all of the permission checks that are carried out by Datasette core, along with the resource
if it was passed.
view-instance¶
Top level permission - Actor is allowed to view any pages within this instance, starting at https://latest.datasette.io/
Default allow.
view-database¶
Actor is allowed to view a database page, e.g. https://latest.datasette.io/fixtures
resource
- stringThe name of the database
Default allow.
view-database-download¶
Actor is allowed to download a database, e.g. https://latest.datasette.io/fixtures.db
resource
- stringThe name of the database
Default allow.
view-table¶
Actor is allowed to view a table (or view) page, e.g. https://latest.datasette.io/fixtures/complex_foreign_keys
resource
- tuple: (string, string)The name of the database, then the name of the table
Default allow.
view-query¶
Actor is allowed to view (and execute) a canned query page, e.g. https://latest.datasette.io/fixtures/pragma_cache_size - this includes executing Writable canned queries.
resource
- tuple: (string, string)The name of the database, then the name of the canned query
Default allow.
execute-sql¶
Actor is allowed to run arbitrary SQL queries against a specific database, e.g. https://latest.datasette.io/fixtures?sql=select+100
resource
- stringThe name of the database
Default allow. See also the default_allow_sql setting.
permissions-debug¶
Actor is allowed to view the /-/permissions
debug page.
Default deny.