Access and Security APIs Archives - SearchStax Docs

Provisioning API – Authentication

admin — Thu, 04 Mar 2021 10:27:07 +0000

Provisioning API – Authentication

Overview

The SearchStax Managed Search service provides an API supporting the creation, deletion, and management of Solr deployments.

Core and Enterprise Clients Only!

The SearchStax API suite is available to our Core and Enterprise clients only, as noted on our Pricing page.

The Provisioning API uses two methods of authentication appropriate to two levels of security:

Token Authentication: Use the username and password of an authorized user to obtain an authentication token. The token authorizes API calls within the normal scope of the user’s permissions. A token expires after 24 hours.
API Key Authentication: The API Key authenticates a narrow set of API functions for managing Solr Basic Auth users and Zookeeper configurations in a deployment. The API Key does not expire, but it can be revoked.

The API can be accessed through any tool that assembles HTTP requests and dispatches them to a server. Among these would be the Python coreapi package, the Postman tool, and cURL. For Windows, use PowerShell 7+.

Account Owner, Admin, or Technical Contact

To run the SearchStax Provisioning API, you must be the account Owner, an account Admin, or a Technical Contact. See SearchStax User Roles.

Symbols enclosed in carets (< and >) such as are metavariables. Substitute your local values when you encounter them in the examples.

Contents:

Token Authentication
- obtain-auth-token > create
- verify-auth-token
API Key Authentication

Token Authentication

The first step in using the SearchStax API is to obtain an authentication token by logging in to the SearchStax server. The token authorizes subsequent API requests.

obtain-auth-token > create

Generates an authentication token for the user of a tenant account. This token expires after 24 hours. If obtain-auth-token API is called within its 24-hour validity window, the token expiration gets extended by another 24 hours.

POST https://app.searchstax.com/api/rest/v2/obtain-auth-token/

POST https://app.searchstax.com/api/rest/v2/obtain-auth-token/

The request body should be an “application/x-www-form-urlencoded” object to accommodate the non-alphanumeric characters that sometimes appear in usernames and passwords.

"username=<username>&password=<password>"

"username=&password="

Parameter	Description	Example
username required string	This is the email address used when you log into the SearchStax server.	“user@company.com”
password required string	This is the password associated with that username.	“4r36%74m”
tfa_token optional string	This is a six-digit code supplied by the Google Authenticator to enable two-factor authentication. Each code is good for one minute, so move fast. The eight-character backup codes work with no time limit, but only once each. If TFA is not enabled for this user account, this token is ignored.	“123456” or “noho2x5n”

When invoked from Linux (Bash script):

TOKEN=$(curl -s -H "Content-Type: application/json" -X POST \
       -d "{\"username\":\"$USER\",\"password\":\"$PASSWORD\",\"tfa_token\":\"$TWOFACTOR\"}" \
       https://app.searchstax.com/api/rest/v2/obtain-auth-token/)

TOKEN=$(curl -s -H "Content-Type: application/json" -X POST \
       -d "{\"username\":\"$USER\",\"password\":\"$PASSWORD\",\"tfa_token\":\"$TWOFACTOR\"}" \
       https://app.searchstax.com/api/rest/v2/obtain-auth-token/)

If SearchStax will not accept your credentials from Bash, check your password for a $, !, or # character. Bash will try to interpret these characters, changing the text of the password. If special characters in the password are a frequent problem, try the cURL command this way:

TOKEN=$(curl -s -H "Content-Type: application/x-www-form-urlencoded" -X POST \
  --data-urlencode "username=$USER" \
  --data-urlencode "password=$PASSWORD" \
  --data-urlencode "tfa_token=$TWOFACTOR" \
  https://app.searchstax.com/api/rest/v1/obtain-auth-token/)

TOKEN=$(curl -s -H "Content-Type: application/x-www-form-urlencoded" -X POST \
  --data-urlencode "username=$USER" \
  --data-urlencode "password=$PASSWORD" \
  --data-urlencode "tfa_token=$TWOFACTOR" \
  https://app.searchstax.com/api/rest/v1/obtain-auth-token/)

When invoked from Windows (PowerShell script):

$USER = "username"
$PASSWORD = "password"
$TFA = "123456"

$body = @{
    username=$USER
    password=$PASSWORD
    tfa_token=$TFA
}

$body = $body | ConvertTo-Json

$TOKEN = Invoke-RestMethod -Method Post -Body $body -ContentType 'application/json' `
        -uri "https://app.searchstax.com/api/rest/v2/obtain-auth-token/" 
$TOKEN = $TOKEN.token

$USER = "username"
$PASSWORD = "password"
$TFA = "123456"

$body = @{
    username=$USER
    password=$PASSWORD
    tfa_token=$TFA
}

$body = $body | ConvertTo-Json

$TOKEN = Invoke-RestMethod -Method Post -Body $body -ContentType 'application/json' `
        -uri "https://app.searchstax.com/api/rest/v2/obtain-auth-token/" 
$TOKEN = $TOKEN.token

The response is a JSON document containing an authorization token.

{
  "token": "aa70cb0a180a0532ae8855f7a1712eeceb81e080"
}

{
  "token": "aa70cb0a180a0532ae8855f7a1712eeceb81e080"
}

Using the token in Bash

In the Bash scripts, the authorization token is incorporated directly in the header of the cURL call:

    curl -s -H "Authorization: Token $TOKEN" etc.

Using the token in PowerShell

In the PowerShell scripts, we use the token by assembling a header for the Invoke-RestMethod call. Note that $TOKEN.token extracts the actual token number from the Json response.


$TOKEN = $TOKEN.token

$headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$headers.Add("Authorization", "Token $TOKEN")

$RESULTS = Invoke-RestMethod -Headers $headers etc.

verify-auth-token

Verifies if the auth token is valid, or needs to be regenerated.

GET https://app.searchstax.com/api/rest/v2/verify-auth-token/

GET https://app.searchstax.com/api/rest/v2/verify-auth-token/

The Authorization header should be passed with the token to verify.

Authorization "Token <token>"

Authorization "Token "

Parameter	Description	Example
token required string	The token to verify	“XyZ190189898njjhjhjhjhjhj”

When invoked from Linux (Bash script):

curl -s -H "Content-Type: application/json" -X GET  \
   -H 'authorization: Token a34085b3f9138e35c38c5acc57cdbcf94f9ec6f2' \
   https://app.searchstax.com/api/rest/v2/verify-auth-token/

curl -s -H "Content-Type: application/json" -X GET  \
   -H 'authorization: Token a34085b3f9138e35c38c5acc57cdbcf94f9ec6f2' \
   https://app.searchstax.com/api/rest/v2/verify-auth-token/

When run from Windows (PowerShell):

$TOKEN = "a34085b3f9138e35c95338cc57cdbcf94f9ec6f2"

$headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$headers.Add("Authorization", "Token $TOKEN")

Write-Host "Verifying an authentication token..."
Write-Host

$RESULT = Invoke-RestMethod -uri "https://app.searchstax.com/api/rest/v2/verify-auth-token/" `
        -Method Get -Headers $headers #-ContentType 'application/json' 

$RESULT = $RESULT | ConvertTo-Json

$TOKEN = "a34085b3f9138e35c95338cc57cdbcf94f9ec6f2"

$headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$headers.Add("Authorization", "Token $TOKEN")

Write-Host "Verifying an authentication token..."
Write-Host

$RESULT = Invoke-RestMethod -uri "https://app.searchstax.com/api/rest/v2/verify-auth-token/" `
        -Method Get -Headers $headers #-ContentType 'application/json' 

$RESULT = $RESULT | ConvertTo-Json

The response is a JSON with the expiry information of the token

{
    "token": {
        "key": "YXBwNDAtYXBpOmdUSG8xNyNrdXU4",
        "created": "2024-03-31T23:46:28Z",
        "duration_days":1,
        "expires": "2024-04-01T23:46:28Z"
    }
}

{
    "token": {
        "key": "YXBwNDAtYXBpOmdUSG8xNyNrdXU4",
        "created": "2024-03-31T23:46:28Z",
        "duration_days":1,
        "expires": "2024-04-01T23:46:28Z"
    }
}

API Key Authentication

An API Key is a non-expiring authorization allowing certain non-SearchStax users to perform a specific set of API operations on specific deployments of a specific account. If you step outside of that scope, you will see an Out of Scope error.

In a little more detail:

You must be the Owner or an Admin of a Core or Enterprise account to generate an API Key.
You will need Token Authentication to create the API Key.
The API Key by itself is not good for anything. The account Owner or an Admin must associate the API Key with a specific deployment before the key becomes active.
At this point, anyone who possesses the API Key (anyone at all) can use SearchStax Provisioning API methods to:
- Manage Solr Basic Auth users on that specific deployment.
- Manage Solr configurations on Zookeeper in that specific deployment.

Note that the API Key is good for absolutely nothing else.

Procedure for creating an APIkey:

Obtain an authentication Token.
Generate an APIkey.
Associate the APIkey with a specific deployment.

Once the APIkey has been associated with a deployment, you can view the APIkey under the Security menu for that deployment in the Managed Search dashboard.

account > apikey > create

This method creates an API Key based on a valid authentication token.

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/apikey/

POST https://app.searchstax.com/api/rest/v2/account//apikey/

where is the name of the tenant account.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "scope":["deployment.dedicateddeployment"]
}

Parameter	Description
scope required list of strings	The scope in which this API key will be effective. Default value is deployment.dedicateddeployment.

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/apikey/" \
  --header "Authorization: Token <token>" \
  --header "Content-Type: application/json" \
  --data "{
    \"scope\":[\"deployment.dedicateddeployment\"]
}"

curl --request POST "https://app.searchstax.com/api/rest/v2/account//apikey/" \
  --header "Authorization: Token " \
  --header "Content-Type: application/json" \
  --data "{
    \"scope\":[\"deployment.dedicateddeployment\"]
}"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"

$body = @{
    scope=@('deployment.dedicateddeployment')   # Force single-value to be a list
}
$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document:

{ "apikey": "eyJhbGciOiJIUzVCJ9.eyJpYXQiOjE1NDMyNDc0ODMsImp0aSI6IjhmYTlkZThjNTIyNjRjZTc2Njg0NTkyMWQ4MTQ0MDY5ZThkMjc5NmMiLCJzY29wZSI6WyJkZXBsb3ltZW50LmRlZGljYXRlZGRlcGxveW1lbnQiXSwiQ1MrdThSZmlNTzMwNnZJM082QSJ9.r6X7bJi_ZWGR99XC0Ac" }

Using the API key in Bash

In the Bash scripts, we use the API key directly in the header of the cURL call:

 curl -s -H "Authorization: APIkey $APIKEY" etc.

Using the API key in PowerShell

In the PowerShell scripts, we use the API key by assembling a header and using it in the Invoke-RestMethod call:

 $headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$headers.Add("Authorization", "APIkey $APIKEY")

$RESULTS = Invoke-RestMethod -Headers $headers etc.

account > apikey > associate_apikey_to_deployment

This method associates an API key to a specific deployment. Note that an API key can be associated with multiple deployments, but each deployment can be associated with only one API key at a time.

POST https://app.searchstax.com/api/rest/v2/account//apikey/associate/

where is the name of the tenant account.

This method requires Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "apikey": "eyJhbGciOiJI6IkpXVCJ9...",
    "deployment": "ss123456"
}

{
    "apikey": "eyJhbGciOiJI6IkpXVCJ9...",
    "deployment": "ss123456"
}

Parameter	Description	Example
apikey required string	This is the API key that needs to be associated with the deployment.	“eyJhbGciOiJI6IkpXVCJ9…”
deployment required string	This is the UID of the deployment.	“ss123456”

When invoked from Linux (Bash script):

curl -s -H "Content-Type: application/json" \
     -H "Authorization: Token $TOKEN" -X POST \
     -d "{\"apikey\":\"$APIKEY\", \"deployment\":\"$uid\"}" \
     https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/associate/

curl -s -H "Content-Type: application/json" \
     -H "Authorization: Token $TOKEN" -X POST \
     -d "{\"apikey\":\"$APIKEY\", \"deployment\":\"$uid\"}" \
     https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/associate/

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    apikey=$APIKEY
    deployment=$uid
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod  -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/associate/"

$RESULT = $RESULT | ConvertTo-Json

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    apikey=$APIKEY
    deployment=$uid
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod  -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/associate/"

$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document containing a list of deployments associated with this key.

{
  "deployments": [ "ssXXXXX1", "ssXXXXX2"]
}

{
  "deployments": [ "ssXXXXX1", "ssXXXXX2"]
}

Note that a deployment may be associated with only one API key at a time. Attempting to associate a second API key results in an error message:

{
  "detail": "Deployment is already associated to another API key."
}

{
  "detail": "Deployment is already associated to another API key."
}

account > apikey > apikey_deployments

This method lists the deployments associated with the given API key.

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/apikey/deployments/

POST https://app.searchstax.com/api/rest/v2/account//apikey/deployments/

where is the name of the tenant account.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "apikey" : "eyJhbGciOiJI6IkpXVCJ9..."
}

{
    "apikey" : "eyJhbGciOiJI6IkpXVCJ9..."
}

Parameter	Description	Example
apikey required string	This is the API key that is associated with the deployments.	“eyJhbGciOiJI6IkpXVCJ9…”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/apikey/deployments/" \
  --header "Authorization: Token <token>" \
  --header "Content-Type: application/json" \
  --data "{ \"apikey\" : \"eyJhbGciOiJI6IkpXVCJ9...\" }"

curl --request POST "https://app.searchstax.com/api/rest/v2/account//apikey/deployments/" \
  --header "Authorization: Token " \
  --header "Content-Type: application/json" \
  --data "{ \"apikey\" : \"eyJhbGciOiJI6IkpXVCJ9...\" }"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$APIKEY = "eyJhbGciOiJI6IkpXVCJ9..."

$body = @{
    apikey=$APIKEY
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/deployments/" 
$RESULT = $RESULT | ConvertTo-Json

$ACCOUNT = "AccountName"
$APIKEY = "eyJhbGciOiJI6IkpXVCJ9..."

$body = @{
    apikey=$APIKEY
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/deployments/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document containing a list of deployment UIDs.

{
  "deployments": [ "ss123456" ]
}

{
  "deployments": [ "ss123456" ]
}

If the username or account name is in error, the API returns this message:

{
  "detail": "You do not have permission to perform this action."
}

{
  "detail": "You do not have permission to perform this action."
}

If the lengthy API key string is in error (usually a line break), the API returns this error:

{"apikey":["Error decoding signature. Unknown API Key"]}

{"apikey":["Error decoding signature. Unknown API Key"]}

account > apikey > deployment_apikeys

This method lists the API key that is associated with a deployment. Each deployment may be associated with only one API key at a time.

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/apikey/list/

POST https://app.searchstax.com/api/rest/v2/account//apikey/list/

where is the name of the tenant account.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "deployment" : "ss123456"
}

{
    "deployment" : "ss123456"
}

Parameter	Description	Example
deployment required string	This is the UID of the deployment.	“ss123456”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/apikey/list/" \
  --header "Authorization: Token <token>" \
  --header "Content-Type: application/json" \
  --data "{ \"deployment\" : \"ss123456\" }"

curl --request POST "https://app.searchstax.com/api/rest/v2/account//apikey/list/" \
  --header "Authorization: Token " \
  --header "Content-Type: application/json" \
  --data "{ \"deployment\" : \"ss123456\" }"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    deployment=$uid
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/list/" 
$RESULT = $RESULT | ConvertTo-Json

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    deployment=$uid
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/list/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document containing the API key associated with the deployment.

{
  "apikey": [ "eyJhbGciOiJI6IkpXVCJ9..." ]
}

{
  "apikey": [ "eyJhbGciOiJI6IkpXVCJ9..." ]
}

account > apikey > disassociate_apikey_from_deployment

This method disassociates an API key from a deployment.

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/apikey/disassociate/

POST https://app.searchstax.com/api/rest/v2/account//apikey/disassociate/

where is the name of the tenant account.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "apikey" : "eyJhbGciOiJI6IkpXVCJ9...",
    "deployment": "ss123456"
}

{
    "apikey" : "eyJhbGciOiJI6IkpXVCJ9...",
    "deployment": "ss123456"
}

Parameter	Description	Example
apikey required string	This is the API key that needs to be disassociated from the deployment.	“eyJhbGciOiJI6IkpXVCJ9…”
deployment required string	This is the UID of the deployment.	“ss123456”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account/<account_name>/apikey/disassociate/" \
  --header "Authorization: Token <token>" \
  --header "Content-Type: application/json" \
  --data "{
    \"apikey\" : \"eyJhbGciOiJI6IkpXVCJ9...\",
    \"deployment\": \"ss123456\"
}"

curl --request POST "https://app.searchstax.com/api/rest/v2/account//apikey/disassociate/" \
  --header "Authorization: Token " \
  --header "Content-Type: application/json" \
  --data "{
    \"apikey\" : \"eyJhbGciOiJI6IkpXVCJ9...\",
    \"deployment\": \"ss123456\"
}"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"
$APIKEY = "eyJhbGciOiJI6IkpXVCJ9..."

$body = @{
    apikey=$APIKEY
    deployment=$uid
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/disassociate/" 
$RESULT = $RESULT | ConvertTo-Json

$ACCOUNT = "AccountName"
$uid = "ss123456"
$APIKEY = "eyJhbGciOiJI6IkpXVCJ9..."

$body = @{
    apikey=$APIKEY
    deployment=$uid
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/disassociate/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document containing a list of deployments with which the API key is still associated.

{
  "deployments": [
    "ssXXXXX1",
    "ssXXXXX2",
    "ssXXXXX3"
  ]
}

{
  "deployments": [
    "ssXXXXX1",
    "ssXXXXX2",
    "ssXXXXX3"
  ]
}

account > apikey > revoke

This method revokes an API key.

POST https://app.searchstax.com/api/rest/v2/account/<account_name>/apikey/revoke/

POST https://app.searchstax.com/api/rest/v2/account//apikey/revoke/

where is the name of the tenant account.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "apikey" : "eyJhbGciOiJI6IkpXVCJ9..."
}

Parameter	Description	Example
apikey required string	This is the API key to revoke.	“eyJhbGciOiJI6IkpXVCJ9…”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account//apikey/revoke/" \
  --header "Authorization: Token " \
  --header "Content-Type: application/json" \
  --data "{
    \"apikey\" : \"eyJhbGciOiJI6IkpXVCJ9...\"
}"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$APIKEY = "eyJhbGciOiJI6IkpXVCJ9..."

$body = @{
    apikey=$APIKEY
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/apikey/revoke/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document containing a success/failure message.

{
  "success": "API Key revoked successfully."
}

Questions?

Do not hesitate to contact the SearchStax Support Desk.

The post Provisioning API – Authentication appeared first on SearchStax Docs.

SearchStax Users API

admin — Thu, 04 Mar 2021 10:23:05 +0000

Provisioning API – Users

Overview

The SearchStax Managed Search service provides an API supporting the creation, deletion and management of SearchStax Managed Search service deployments.

Core and Enterprise Clients Only!

The SearchStax API suite is available to our Core and Enterprise clients only, as noted on our Pricing page.

This page describes how to manage the users of a SearchStax account through the API.

The API can be accessed through any tool that assembles HTTP requests and dispatch them to a server. Among these would be the Python coreapi package, the Postman tool, and cURL. For Windows, use PowerShell 7+.

Account Owner, Admin, or Technical Contact

To run the SearchStax Provisioning API, you must be the account Owner, an account Admin, or a Technical Contact. See SearchStax User Roles.

Symbols enclosed in carets (< and >) such as are metavariables. Substitute your local values when you encounter them in the examples.

Contents:

Users

Users

The SearchStax Provisioning API provides methods for managing the users of a SearchStax Account from a remote application.

users > list

This method lists the SearchStax users for an account.

GET https://app.searchstax.com/api/rest/users/?account=

where ?account= is the name of the tenant account.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET https://app.searchstax.com/api/rest/users/?account=$ACCOUNT 
  --header "Authorization: Token "

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"

$RESULT = Invoke-RestMethod -Method Get -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/users/?account=$ACCOUNT" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document containing the SearchStax users of the account and their details:

{
  "success": true,
  "users": [
    {
      "firstname": "FirstName",
      "lastname": "LastName",
      "email": "user@company.com",
      "role": "Team Member",
      "sitesearch_role": "Team Member",
      "tfa_enabled": false,
      "phone": "123-456-7890",
      "company": "Company",
      "id": 3201,
      "last_login": "2025-09-19T16:09:15Z",
      "created": "2021-01-06T19:51:28Z",
      "invitation_status": "Completed",
      "role_in_organization": "Engineer"
    }
  ]
}

{
  "success": true,
  "users": [
    {
      "firstname": "FirstName",
      "lastname": "LastName",
      "email": "user@company.com",
      "role": "Team Member",
      "sitesearch_role": "Team Member",
      "tfa_enabled": false,
      "phone": "123-456-7890",
      "company": "Company",
      "id": 3201,
      "last_login": "2025-09-19T16:09:15Z",
      "created": "2021-01-06T19:51:28Z",
      "invitation_status": "Completed",
      "role_in_organization": "Engineer"
    }
  ]
}

users > add-user > create

This method invites a new user to join an existing tenant account.

POST https://app.searchstax.com/api/rest/users/add-user?account=

where ?account= is the name of the tenant account.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "email": "user@company.com",
    "role": "Admin",
    "first_name": "First",
    "last_name": "Last",    
    "phone_number": "8005551212"
}

Parameter	Description
email required string	The user’s email.
role required string	One of ‘Admin’, ‘Technical Contact’, ‘Billing Member’, ‘Team Member’.
first_name required string	User’s first name.
last_name required string	User’s last name.
phone_number optional string	User’s phone number.

When invoked from Linux (Bash script):

curl -s -H "Authorization: Token $TOKEN" -H "Content-Type: application/json" -d "${BODY}" 
-X POST https://app.searchstax.com/api/rest/users/add-user?account=$ACCOUNT

When invoked from Windows (PowerShell script):

$body = @{
    email='user@company.com'
    role='Admin'
    first_name='First'
    last_name='Last'    
    phone_number='8005551212'
}

$body = $body | ConvertTo-Json

$RESULTS = Invoke-RestMethod -Method Post -Body $body -ContentType 'application/json' -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/users/add-user?account=$ACCOUNT" 
$RESULTS = $RESULTS | ConvertTo-Json

This method returns a JSON document containing a success message.

{
  "success": true,
  "message": "User 'user@company.com' invited successfully."
}

users > change-password > create

This method allows an authenticated user to change his own password. It is not possible to change someone else’s password.

POST https://app.searchstax.com/api/rest/users/change-password?account=<account_name>&id=<id>

POST https://app.searchstax.com/api/rest/users/change-password?account=&id=

where ?account= is the name of the tenant account, and id= is the user identification number obtained from users > list.

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following item:

{
    "password": "NewPasswordString"
}

{
    "password": "NewPasswordString"
}

Parameter	Description
password required string	The desired new password. The password should contain at least one upper-case letter, one lower-case letter, one number, one special character and be from 15 and 64 characters long.

When invoked from Linux (Bash script):

curl -s -H "Authorization: Token $TOKEN" -H "Content-Type: application/json" -d '{"password": "NewPasswordString"}' /
-X POST "https://app.searchstax.com/api/rest/users/change-password?account=$ACCOUNT&$ID"

curl -s -H "Authorization: Token $TOKEN" -H "Content-Type: application/json" -d '{"password": "NewPasswordString"}' /
-X POST "https://app.searchstax.com/api/rest/users/change-password?account=$ACCOUNT&$ID"

When invoked from Windows (PowerShell script):

$body = @{
    password='NewPasswordString'
}

$body = $body | ConvertTo-Json

$RESULTS = Invoke-RestMethod -Method Post -Body $body -ContentType 'application/json' -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/users/change-password?account=$ACCOUNT&id=$ID" 
 
$RESULTS = $RESULTS | ConvertTo-Json

$body = @{
    password='NewPasswordString'
}

$body = $body | ConvertTo-Json

$RESULTS = Invoke-RestMethod -Method Post -Body $body -ContentType 'application/json' -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/users/change-password?account=$ACCOUNT&id=$ID" 
 
$RESULTS = $RESULTS | ConvertTo-Json

This method returns a JSON document containing a success message.

{
    "success":  true,
    "message":  "Password changed successfully."
}

{
    "success":  true,
    "message":  "Password changed successfully."
}

If you received an error saying, “You can not change password for another user,” check to be sure the URL is within double-quotes. If not, everything to the right of the ampersand (&) will be truncated, usually resulting in the loss of the user ID.

users > set-role > create

Managed Search User Roles

For background on user roles in Managed Search, see Role-based User Roles for Your SearchStax Team and User Management.

This method allows an Author or Admin to change the role of one or more account users.

POST https://app.searchstax.com/api/rest/users/set-role/?account=

where ?account= is the name of the tenant account..

This method uses Token authentication.

The request body should be a “application/json” encoded object, containing the following item:

{
    "id": "2178,2067,3385",
    "role": "Team Member"
}

Parameter	Description
id required string	A comma-separated list of user ID numbers obtained from users > list.
role required string	One of Admin, Technical Contact, Billing Member, Team Member, Marketer. All users in the id list will be assigned to this role.

When invoked from Linux (Bash script):

curl -s -H "Authorization: Token $TOKEN" -H "Content-Type: application/json" -d "${BODY}" 
-X POST "https://app.searchstax.com/api/rest/users/set-role?account=$ACCOUNT"

When invoked from Windows (PowerShell script):

$body = @{
    id='2178,2067,3385'
    role='Team Member'
}

$body = $body | ConvertTo-Json

$RESULTS = Invoke-RestMethod -Method Post -Body $body -ContentType 'application/json' -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/users/set-role?account=$ACCOUNT" 
 
$RESULTS = $RESULTS | ConvertTo-Json

This method returns a JSON document containing a success/failure message for each user.

[
  {
    "id": 2178,
    "success": true,
    "message": "Role updated successfully."
  },
  {
    "id": 2067,
    "success": false,
    "message": "User id 2067 does not exist."
  },
  {
    "id": 3385,
    "success": true,
    "message": "Role updated successfully."
  }
]

[
  {
    "id": 2178,
    "success": true,
    "message": "Role updated successfully."
  },
  {
    "id": 2067,
    "success": false,
    "message": "User id 2067 does not exist."
  },
  {
    "id": 3385,
    "success": true,
    "message": "Role updated successfully."
  }
]

users > delete

This method deletes a SearchStax user from an Account.

DELETE https://app.searchstax.com/api/rest/users/?account=&id=

where ?account= is the name of the tenant account, and &id= is the ID of the user.

This method uses Token authentication.

There is no request body.

When invoked from Linux (Bash script):

curl -H "Content-Type: application/json" -H "Authorization: Token $TOKEN" 
     -X DELETE "https://app.searchstax.com/api/rest/users/?account=$ACCOUNT&id=$DELUSER"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$DELUSER = "1234"

$RESULT = Invoke-RestMethod -Method Delete -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/users/?account=$ACCOUNT&id=$DELUSER" 
$RESULT = $RESULT | ConvertTo-Json

This method returns a JSON document containing a success message.

{
   "id":3204,
   "success":true,
   "message":"User deleted successfully."
}

Questions?

Do not hesitate to contact the SearchStax Support Desk.

The post SearchStax Users API appeared first on SearchStax Docs.

Solr Basic Auth API

admin — Thu, 04 Mar 2021 10:10:05 +0000

Provisioning API – Basic Auth

Overview

The SearchStax Managed Search service provides an API supporting the creation, deletion and management of Solr deployments.

Core and Enterprise Clients Only!

The SearchStax API suite is available to our Core and Enterprise clients only, as noted on our Pricing page.

This page describes how to manage Solr Basic Auth features through the API.

Account Owner, Admin, or Technical Contact

To run the SearchStax Provisioning API, you must be the account Owner, an account Admin, or a Technical Contact. See SearchStax User Roles.

Symbols enclosed in carets (< and >) such as are metavariables. Substitute your local values when you encounter them in the examples.

Contents:

Solr Basic Auth

Solr Basic Auth

The SearchStax Provisioning API provides a selection of methods for managing Solr basic authentication from a remote application.

account > deployment > solr > auth > enable_basic_auth

This method enables basic auth for a Solr deployment. Note that this process takes Solr offline for about 30 seconds to restart it.

GET https://app.searchstax.com/api/rest/v2/account/<account_name>/deployment/<uid>/solr/auth/enable/

GET https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/enable/

where is the name of the tenant account, and is the ID of the deployment.

This method uses either Token authentication or API Key authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/enable/" \
  --header "Authorization: APIkey "

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$RESULT = Invoke-RestMethod -Method Get -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/solr/auth/enable/" 
$RESULT = $RESULT | ConvertTo-Json

This method returns a JSON document containing a success message.

{
  "message": "Basic authentication successfully Enabled for Solr",
  "success": "true"
}

account > deployment > solr > auth > disable_basic_auth

This method disables basic auth for a Solr deployment. Note that this process takes Solr offline for about 30 seconds to restart it.

GET https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/disable/

where is the name of the tenant account, and is the ID of the deployment.

This method uses either Token authentication or API Key authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/disable/" \
  --header "Authorization: APIkey " \

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$RESULT = Invoke-RestMethod -Method Get -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/solr/auth/disable/" 
$RESULT = $RESULT | ConvertTo-Json

This method returns a JSON document containing a success message.

{
  "message": "Basic authentication successfully Disabled for Solr",
  "success": "true"
}

account > deployment > solr > auth > add_solr_user

This method adds a Solr user to the deployment. Basic auth must be enabled.

POST https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/add-user/

where is the name of the tenant account, and is the ID of the deployment.

This method uses either Token authentication or API Key authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "username" : "demoSolrUser",
    "password" : "test123",
    "role" : "Admin"
}

Parameter	Description	Example
username required string	This is the Solr user name.	“demoSolrUser”
password required string	This is the Solr user’s password.	“test123”
role required string	This is the Solr role: Admin, Read, Write, or ReadWrite.	“Admin”

See Solr Basic Authentication for an explanation of the Solr roles.

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/add-user/" \
  --header "Authorization: Token " \
  --header "Content-Type: application/json" \
  --data "{
    \"username\" : \"demoSolrUser\",
    \"password\" : \"test123\",
    \"role\" : \"Admin\"
}"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    username='demoSolrUser'
    password='test123'
    role='Admin'
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/solr/auth/add-user/" 
$RESULT = $RESULT | ConvertTo-Json

This method returns a JSON document containing a success message.

{
  "message": "User successfully added",
  "success": "true"
}

account > deployment > solr > auth > delete_solr_user

This method deletes a Solr user from a deployment.

POST https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/delete-user/

where is the name of the tenant account, and is the ID of the deployment.

This method uses either Token authentication or API Key authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "username" : "demoSolrUser"
}

Parameter	Description	Example
username required string	This is the Solr user name.	“demoSolrUser”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/delete-user/" \
  --header "Authorization: APIkey " \
  --header "Content-Type: application/json" \
  --data "{
    \"username\" : \"demoSolrUser\"
}"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    username='demoSolrUser'
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/solr/auth/delete-user/" 
$RESULT = $RESULT | ConvertTo-Json

This method returns a JSON document containing a success message.

{
  "message": "User successfully deleted!",
  "success": "true"
}

account > deployment > solr > auth > get_solr_users

This method gets the Solr users for a deployment.

GET https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/get-users/

where is the name of the tenant account, and is the ID of the deployment.

This method uses either Token authentication or API Key authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/get-users/" \
  --header "Authorization: APIkey "

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$RESULT = Invoke-RestMethod -Method Get -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/solr/auth/get-users/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document containing the Solr users and the roles associated with them.

{
  "success": "true",
  "users": {
    "demoSolrUser": {
      "roles": [ "Read", "Write", "Admin" ]
    }
  }
}

account > deployment > solr > auth > set_solr_user_password

This method sets a password for a Solr user.

POST https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/set-password/

where is the name of the tenant account, and is the ID of the deployment.

This method uses either Token authentication or API Key authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "username" : "demoSolrUser",
    "password": "test456"
}

Parameter	Description	Example
username required string	This is the Solr user name.	“demoSolrUser”
password required string	This is the Solr user’s password.	“test456”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/set-password/" \
  --header "Authorization: APIkey " \
  --header "Content-Type: application/json" \
  --data "{
    \"username\" : \"demoSolrUser\",
    \"password\": \"test456\"
}"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    username='demoSolrUser'
    password='test456'
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/solr/auth/set-password/" 
$RESULT = $RESULT | ConvertTo-Json

This method returns a JSON document containing a success message.

{
  "message": "Password successfully updated!",
  "success": "true"
}

account > deployment > solr > auth > set_solr_user_role

This method sets the Solr user’s role. Available roles are Admin, Read, Write, and ReadWrite.

POST https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/set-role/

where is the name of the tenant account, and is the ID of the deployment.

This method uses either Token authentication or API Key authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    "username" : "demoSolrUser",
    "role" : "Read"
}

Parameter	Description	Example
username required string	This is the Solr user name.	“demoSolrUser”
role required string	This is the Solr role: Admin, Read, Write, or ReadWrite.	“Read”

See Solr Basic Authentication for an explanation of the Solr roles.

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account//deployment//solr/auth/set-role/" \
  --header "Authorization: APIkey " \
  --header "Content-Type: application/json" \
  --data "{
    \"username\" : \"demoSolrUser\",
    \"role\" : \"Read\"
}"

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    username='demoSolrUser'
    role='Read'
}

$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/solr/auth/set-role/" 
$RESULT = $RESULT | ConvertTo-Json

This method returns a JSON document containing a success message.

{
  "message": "Successfully updated user role!",
  "success": "true"
}

Questions?

Do not hesitate to contact the SearchStax Support Desk.

The post Solr Basic Auth API appeared first on SearchStax Docs.

Solr IP Filtering API

admin — Thu, 04 Mar 2021 09:57:52 +0000

Provisioning API – IP Filtering

Overview

The SearchStax Managed Search service provides an API supporting the creation, deletion and management of Solr deployments.

Core and Enterprise Clients Only!

The SearchStax API suite is available to our Core and Enterprise clients only, as noted on our Pricing page.

This page describes how to set up IP Filtering using the API methods.

Account Owner, Admin, or Technical Contact

To run the SearchStax Provisioning API, you must be the account Owner, an account Admin, or a Technical Contact. See SearchStax User Roles.

Symbols enclosed in carets (< and >) such as are metavariables. Substitute your local values when you encounter them in the examples.

Contents:

IP Filtering

IP Filtering

The SearchStax Provisioning API includes methods for applying IP Filters to deployments.

account > deployment > ip-filter > list

This method returns a list of IP Filters from a deployment.

GET /api/rest/v2/account//deployment//ip-filter/?page=

where is the name of the tenant account, and is the ID of the deployment. The query parameter page is a number, , that defaults to 1.

This method uses either Token authentication or API Key authentication.

There is no request body.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account//deployment//ip-filter/?page=" \
  --header "Authorization: Token "

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$RESULTS = Invoke-RestMethod -Method Get -Headers $headers `
          -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/ip-filter/?page=1" 
$RESULTS = $RESULTS | ConvertTo-Json

The response is a JSON document containing a list of IP Filters.

[
  {
    "services": [
      "solr"
    ],
    "cidr_ip": "0.0.0.0/0",
    "description": ""
  }
]

account > deployment > ip-filter > add-cidr-ip

Setting IP Filters on Azure Deployments

When using add-cidr-ip in an Azure environment, IP filters for Zookeeper and Solr must both be explicitly set.

SearchStax requires Zookeeper to be locked down by IP filters. To then leave Solr open to any connection (a common request), set the Solr IP filter to ‘0.0.0.0/0’.

This method adds a new IP Filter to a deployment.

POST https://app.searchstax.com/api/rest/v2/account//deployment//ip-filter/add-cidr-ip/

where is the name of the tenant account, and is the ID of the deployment.

This method uses either Token authentication or API Key authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    services=@('solr','zk')
    cidr_ip='100.100.100.100'
    description='Added by API'
}

Parameter	Description	Example
services required list of strings	Which services to apply the filter to. Allowed values are ‘solr’ and ‘zk’.	(‘solr’,’zk’)
cidr_ip required string	The IP address.	“100.100.100.100”
description optional string	A very brief label.	“Added by API”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account//deployment//ip-filter/add-cidr-ip/" \
  --header "Content-Type: application/json" \
  --header "Authorization: Token " \
  --data '{"services":["solr","zk"],"cidr_ip":"100.100.100.100","description":"Added by API"}'

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    services=@('solr','zk')
    cidr_ip='100.100.100.100'
    description='Added by PowerShell'
}
$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/ip-filter/add-cidr-ip/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document confirming success.

{
  "detail": null,
  "success": true
}

account > deployment > ip-filter > delete-cidr-ip

This method deletes an IP Filter from a deployment.

POST https://app.searchstax.com/api/rest/v2/account//deployment//ip-filter/delete-cidr-ip/

where is the name of the tenant account, and is the ID of the deployment.

This method uses either Token authentication or API Key authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    cidr_ip='100.100.100.100'
}

Parameter	Description	Example
cidr_ip required string	The IP address of the filter to delete.	“100.100.100.100”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account//deployment//ip-filter/delete-cidr-ip/" \
  --header "Content-Type: application/json" \
  --header "Authorization: Token " \
  --data '{"cidr_ip":"100.100.100.100"}'

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    cidr_ip='100.100.100.100'
}
$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/ip-filter/delete-cidr-ip/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document confirming success.

{
  "detail": null,
  "success": true
}

account > deployment > ip-filter > update-cidr-ip

This method updates an IP Filter in a deployment.

POST https://app.searchstax.com/api/rest/v2/account//deployment//ip-filter/update-cidr-ip/

where is the name of the tenant account, and is the ID of the deployment.

This method uses either Token authentication or API Key authentication.

The request body should be a “application/json” encoded object, containing the following items:

{
    services=@('solr','zk')
    cidr_ip='100.100.100.100'
    description='Updated by API'
}

Parameter	Description	Example
services required list of strings	Which services to apply the filter to. Allowed values are ‘solr’ and ‘zk’.	(‘solr’,’zk’)
cidr_ip required string	The IP address.	“100.100.100.100”
description optional string	A very brief label.	“Added by API”

When invoked from Linux (Bash script):

curl --request POST "https://app.searchstax.com/api/rest/v2/account//deployment//ip-filter/add-cidr-ip/" \
  --header "Content-Type: application/json" \
  --header "Authorization: Token " \
  --data '{"services":["solr","zk"],"cidr_ip":"100.100.100.100","description":"Updated by API"}'

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"
$uid = "ss123456"

$body = @{
    services=@('solr','zk')
    cidr_ip='100.100.100.100'
    description='Updated by PowerShell'
}
$body = $body | ConvertTo-Json

$RESULT = Invoke-RestMethod -Method Post -body $body -ContentType 'application/json' -Headers $headers `
         -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/deployment/$uid/ip-filter/update-cidr-ip/" 
$RESULT = $RESULT | ConvertTo-Json

The response is a JSON document confirming success.

{
  "detail": null,
  "success": true
}

Questions?

Do not hesitate to contact the SearchStax Support Desk.

The post Solr IP Filtering API appeared first on SearchStax Docs.

Private VPC API

Bruce — Fri, 24 Jun 2022 01:18:46 +0000

Private VPC API

The SearchStax Managed Search service provides an API supporting the creation, deletion and management of Solr deployments.

Core and Enterprise Clients Only!

The SearchStax API suite is available to our Core and Enterprise clients only, as noted on our Pricing page.

This page describes how to obtain the ID number of a Virtual Private Cloud (VPC) using the API. This ID is essential to creating a new deployment inside the VPC using the account > deployment > create method.

Account Owner, Admin, or Technical Contact

To run the SearchStax Provisioning API, you must be the account Owner, an account Admin, or a Technical Contact. See SearchStax User Roles.

Symbols enclosed in carets (< and >) such as are metavariables. Substitute your local values when you encounter them in the examples.

Contents:

Private VPC API
- account > privatevpc > list

Private VPC API

SearchStax provides the ability to create new Solr deployments within your VPC using the account > deployment > create method. That method, in turn, requires the ID number of the VPC in your account. The following method lets you obtain this ID number.

account > privatevpc > list

This method lists VPCs associated with an account.

GET /api/rest/v2/account//privatevpc/?page=1

where is the name of the tenant account, and is an optional page number within the paginated result set.

This method uses Token authentication.

When invoked from Linux (Bash script):

curl --request GET "https://app.searchstax.com/api/rest/v2/account//privatevpc" 
  --header "Authorization: Token "

When invoked from Windows (PowerShell script):

$ACCOUNT = "AccountName"

$RESULT = Invoke-RestMethod -Method Get -ContentType 'application/json' -Headers $headers `
              -uri "https://app.searchstax.com/api/rest/v2/account/$ACCOUNT/privatevpc/"
$RESULT = $RESULT | ConvertTo-Json

A successful response is a JSON object describing the VPCs of the account:

{
  "count": 1,
  "next": null,
  "previous": null,
  "results": [
    {
      "id": 2,
      "account": "test",
      "region": "us-east1",
      "status": "Active",
      "address_space": "10.63.0.0/16",
      "name": "test-vpc"
    }
  ]
}

Questions?

Do not hesitate to contact the SearchStax Support Desk.

The post Private VPC API appeared first on SearchStax Docs.