The following describes the structure of an indices permissions entry:

{
  "names": [ ... ], 
  "privileges": [ ... ], 
  "field_security" : { ... }, 
  "query": "..." 
}

When specifying index names, you can use indices and aliases with their full names or regular expressions that refer to multiple indices.

• Wildcard (default) - simple wildcard matching where * is a placeholder for zero or more characters, ? is a placeholder for a single character and \ may be used as an escape character.
• Regular Expressions - A more powerful syntax for matching more complex patterns. This regular expression is based on Lucene’s regexp automaton syntax. To enable this syntax, it must be wrapped within a pair of forward slashes (/). Any pattern starting with / and not ending with / is considered to be malformed.

Example Regular Expressions. 

"foo-bar":               # match the literal `foo-bar`
"foo-*":                 # match anything beginning with "foo-"
"logstash-201?-*":       # ? matches any one character
"/.*-201[0-9]-.*/":      # use a regex to match anything containing 2010-2019
"/foo":                  # syntax error - missing final /

The following describes the structure of a global privileges entry:

{
  "application": {
    "manage": {    
        "applications": [ ... ] 
    }
  }
}

The following describes the structure of an application privileges entry:

{
  "application": "my_app", 
  "privileges": [ ... ],   
  "resources": [ ... ]     
}

For details about the validation rules for these fields, see the add application privileges API.

A role may refer to application privileges that do not exist - that is, they have not yet been defined through the add application privileges API (or they were defined, but have since been deleted). In this case, the privilege has no effect, and will not grant any actions in the has privileges API.

The following snippet shows an example definition of a clicks_admin role:

POST /_xpack/security/role/clicks_admin
{
  "run_as": [ "clicks_watcher_1" ],
  "cluster": [ "monitor" ],
  "indices": [
    {
      "names": [ "events-*" ],
      "privileges": [ "read" ],
      "field_security" : {
        "grant" : [ "category", "@timestamp", "message" ]
      },
      "query": "{\"match\": {\"category\": \"click\"}}"
    }
  ]
}

Based on the above definition, users owning the clicks_admin role can:

For a complete list of available cluster and indices privileges

There are two available mechanisms to define roles: using the Role Management APIs or in local files on the Elasticsearch nodes. You can also implement custom roles providers. If you need to integrate with another system to retrieve user roles, you can build a custom roles provider plugin. For more information, see Custom Roles Provider Extension.

Role management UIedit

You can manage users and roles easily in Kibana. To manage roles, log in to Kibana and go to Management / Elasticsearch / Roles.

Role management APIedit

The Role Management APIs enable you to add, update, remove and retrieve roles dynamically. When you use the APIs to manage roles in the native realm, the roles are stored in an internal Elasticsearch index. For more information and examples, see role management APIs.

File-based role managementedit

Apart from the Role Management APIs, roles can also be defined in local roles.yml file located in ES_PATH_CONF. This is a YAML file where each role definition is keyed by its name.

If the same role name is used in the roles.yml file and through the Role Management APIs, the role found in the file will be used.

While the Role Management APIs is the preferred mechanism to define roles, using the roles.yml file becomes useful if you want to define fixed roles that no one (beside an administrator having physical access to the Elasticsearch nodes) would be able to change.

The roles.yml file is managed locally by the node and is not globally by the cluster. This means that with a typical multi-node cluster, the exact same changes need to be applied on each and every node in the cluster.

A safer approach would be to apply the change on one of the nodes and have the roles.yml distributed/copied to all other nodes in the cluster (either manually or using a configuration management system such as Puppet or Chef).

The following snippet shows an example of the roles.yml file configuration:

click_admins:
  run_as: [ 'clicks_watcher_1' ]
  cluster: [ 'monitor' ]
  indices:
    - names: [ 'events-*' ]
      privileges: [ 'read' ]
      field_security:
        grant: ['category', '@timestamp', 'message' ]
      query: '{"match": {"category": "click"}}'

Elasticsearch continuously monitors the roles.yml file and automatically picks up and applies any changes to it.