Update API key

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Update an existing API key that is valid for 300 seconds
res = client.update_api_key('YourAPIKey', { 
  acl: ['search'], 
  validity: 300
})
puts res['key']

# Update an existing index-specific API key:
#  - valid for 300 seconds
#  - rate limit of 100 calls per hour per IP
#  - maximum of 20 hits
#  - valid on 'your_index1' and 'your_index2'
res = client.update_api_key('YourAPIKey', {
  acl: ['search'],
  validity: 300,
  maxQueriesPerIPPerHour: 100,
  maxHitsPerQuery: 20,
  indexes: ['your_index1', 'your_index2']
})
puts res['key']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Update an existing API key that is valid for 300 seconds
client.updateApiKey('YourAPIKey', {
  acl: ['search'],
  validity: 300,
}).then(({ key }) => {
  console.log(key);
});

// Update an existing index-specific API key valid for 300 seconds, with a rate limit of 100 calls per hour per IP and a maximum of 20 hits
client.updateApiKey('YourAPIKey', {
  acl: ['search'],
  validity: 300,
  maxQueriesPerIPPerHour: 100,
  maxHitsPerQuery: 20,
}).then(({ key }) => {
  console.log(key);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Update an existing API key that is valid for 300 seconds
res = client.update_api_key('YourAPIKey', {
    'acl' => ['search'],    
    'validity': 300,
})

print('key=%s' % res['key'])

# Update an existing index-specific API key valid for 300 seconds, with a rate limit of 100 calls per hour per IP and a maximum of 20 hits
res = client.update_api_key('YourAPIKey', {
    'acl' => ['search'],
    'validity': 300,
    'maxQueriesPerIPPerHour': 100,
    'maxHitsPerQuery': 20,
})

print('key=%s' % res['key'])

1
2
3
4
5
6
7
8
9
10
11
12
13
// Update an existing index-specific API key valid for 300 seconds,
// with a rate limit of 100 calls per hour per IP and a maximum of 20 hits

let parameters = APIKeyParameters(ACLs: [.search])
  .set(\.indices, to: ["dev_*"])
  .set(\.maxHitsPerQuery, to: 20)
  .set(\.maxQueriesPerIPPerHour, to: 100)
  .set(\.validity, to: 300)

client.updateAPIKey("YourAPIKey", with: parameters) { result in
  if case .success(let response) = result {
  }
}

1
2
3
4
5
6
7
8
9
10
11
// Update an existing index-specific API key valid for 300 seconds,
// with a rate limit of 100 calls per hour per IP and a maximum of 20 hits
val apiKey = APIKeyParams(
    ACLs = listOf(ACL.Search),
    indices = listOf(IndexName("dev_*")),
    maxHitsPerQuery = 20,
    maxQueriesPerIPPerHour = 100,
    validity = 300
)

client.updateAPIKey(APIKey("YourAPIKey"), apiKey)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Update an existing API key that is valid for 300 seconds
ApiKey apiKeyToUpdate = new ApiKey
{
    Value = "YourAPIKey",
    Acl = new List<string> { "search" },
    MaxHitsPerQuery = 0,
    MaxQueriesPerIPPerHour = 0,
    Validity = 300
};

var res = client.UpdateApiKey(apiKeyToUpdate);

// Asynchronous
var res = await client.UpdateApiKeyAsync(apiKeyToUpdate);

// Update an existing index-specific API key valid for 300 seconds,
// with a rate limit of 100 calls per hour per IP and a maximum of 20 hits
ApiKey apiKeyToUpdate = new ApiKey
{
    Value = "YourAPIKey",
    Acl = new List<string> { "search" },
    Indexes = new List<string> { "dev_*" },
    MaxHitsPerQuery = 20,
    MaxQueriesPerIPPerHour = 100,
    Validity = 300
};

var res = index.UpdateApiKey(apiKeyToUpdate);

// Asynchronous
var res = await index.UpdateApiKeyAsync(apiKeyToUpdate);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Creates a new API key that is valid for 300 seconds

ApiKey apiKey = new ApiKey()
    .setValue("YourAPIKey")
    .setAcl(Collections.singletonList("search"))
    .setValidity(300);

client.updateApiKey(apiKey);

// Async 
client.updateApiKeyAsync(apiKey);

// Update an index-specific API key valid for 300 seconds,
// with a rate limit of 100 calls per hour per IP and a maximum of 20 hits

ApiKey apiKey = new ApiKey()
    .setValue("YourAPIKey")
    .setAcl(Arrays.asList("search"))
    .setValidity(300L)
    .setMaxQueriesPerIPPerHour(200)
    .setMaxHitsPerQuery(20);

client.updateApiKey(apiKey);

// Async
client.updateApiKeyAsync(apiKey);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Update an existing index-specific API key valid for 5 minutes, with a rate
// limit of 100 calls per hour per IP and a maximum of 20 hits
key := search.Key{
  ACL:                    []string{"search"},
  Indexes:                []string{"dev_*"}
  Validity:               5 * time.Minute,
  MaxQueriesPerIPPerHour: 100,
  MaxHitsPerQuery:        20,
  Value:                  "f420238212c54dcfad07ea0aa6d5c45f",
}

res, err := client.UpdateAPIKey(key)
res.Wait()
fmt.Println(res.Key)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Creates a new API key that is valid for 300 seconds
client.execute {
  update key "YourAPIKey" `with` ApiKey(
      acl = Some(Seq(Acl.search)),
      maxHitsPerQuery = Some(0)),
      maxQueriesPerIPPerHour = Some(0),
      validity = Some(300)
  )
}

// Update a index-specific API key valid for 300 seconds,
// with a rate limit of 100 calls per hour per IP and a

val apiKey = ApiKey(
  acl = Some(Seq(Acl.search)),
  maxHitsPerQuery = Some(100)),
  maxQueriesPerIPPerHour = Some(100),
  validity = Some(300)
)

client.execute {
  update key "YourAPIKey" `with` apiKey from "YourIndex"
}