Além de acessar armazenamentos de dados usando Lua DataStoreService em servidores ou na nuvem, você pode usar as APIs de Nuvem Aberta para acessar e usar dados padrão e 1>armazenamentos de dados solicitados1> de scripts e ferramentas com controle de acesso e segurança granulares.
As APIs da Nuvem são APIs de subprocesso que podem ser alteradas para armazenamentos de dados futuros.
Uso
Você pode melhorar várias áreas do seu fluxo de trabalho ao acessar seus dados com essas APIs, como:
Portal de Suporte ao Cliente : Armazenamento de dados é útil para armazenar recursos de usuário persistentes, como itens em inventários de usuários ou pontos de habilidade. Às vezes, você precisa atualizar esses recursos para o suporte ao cliente. Em vez de usar o Studio ou entrar em uma experiência manualmente, você pode construir uma aplicação web para permitir que seus agentes de suporte ao cliente lidem diretamente com solicitações de suporte ao cliente, como visual
Painel de LiveOps : Você pode construir um painel de LiveOps usando as APIs para melhorar a eficiência das operações ao vivo, como a programação de eventos na experiência. Você pode codificar um evento com antecedência, escondê-lo sob uma bandeira de recurso como parte dos dados de configuração em um armazenamento de dados e configurar um tempo para alternar a bandeira para publicar o evento. Seus servidores de experiência podem detectar ess
Leaderboard Externa : Para promover suas experiências fora do Roblox, você pode puxar as informações de sua experiência, como a tabela de classificação de uma corrida, em tempo real e exibi-las em um site externo. Você pode conceder acesso de leitura apenas às suas lojas de dados ordenadas para que o site solicite periódicamente os dados mais recentes através do HTTP e atualize a página da web.
Automatização de M migração de dados : Os dados podem mudar ou atualizar à medida que sua experiência evolui, como atualizar esquemas de dados para acomodar novos recursos. Para evitar perder dados existentes, às vezes você precisa migrar seus armazenamentos de dados do velho para um novo. Você pode escrever um script externo que lê cada entrada dos armazenamentos de dados atuais,
Diferenças com a API (Interface de Programação para Aplicações)Lua
Embora as APIs abertas sejam semelhantes às APIs Lua DataStoreService, existem alguns requisitos diferentes para serem conscientes:
ID e nome do armazenamento de dados do universo : Diferente da API (Interface de Programação para Aplicações)Lua, as APIs Open Cloud são estáticas e podem vir de qualquer lugar, então você sempre precisa fornecer o ID do universo , o identificador exclusivo de sua experiência, e o nome do armazenamento de dados do nome ao enviar as solicitações. Para mais informações sobre como obter um ID de universo, veja 0>N
Permissões separadas para criar e atualizar : A API Lua cria novas entradas se elas não existirem quando você chamar DataStore:SetAsync() , mas métodos Open Cloud para criar e atualizar entradas são separados. Permissões separadas podem ser mais seguras e mais flexíveis em alguns cenários. Por exemplo, você pode criar uma ferramenta de suporte ao cliente que pode
Serialização de dados : Todos os pontos de terminação de nuvem aberta exigem que você serialize todos os dados antes da rede. A serialização significa converter um objeto em sua string / cadeia / texto, e a deserialização é sua opção oposta (converta um string em um Objeto). A API Lua serializa e deserializa automaticamente o conteúdo de entrada, mas para o Open Cloud você precisa gerar ou processar seus dados de entrada com JSON por conta possuir.
Permissões de Segurança
Os armazenamentos de dados normalmente armazenam informações sensíveis, como perfis de usuário e moedas virtuais. Para manter a segurança, cada Open Cloud API tem permissões correspondentes que você deve adicionar à sua chave API, como a permissão List Keys para a API (Interface de Programação para Aplicações)de listagem. Se você não adicionar as permissões necessárias, sua chamada de API retorna um erro
Quando ajustando suas chaves de API, você pode configurar permissões granulares, como ler, escrever e listar entrada, para cada armazenamento de dados dentro de uma experiência específica, ou você pode dar uma chave para ler ou escrever todos os armazenamentos de dados dentro de uma experiência. Você também pode limitar o acesso a um subconjunto de armazenamentos de dados necessários para sua ferramenta, em vez de expor todos os
Ferramentas de Construção
Você pode usar o idioma de sua escolha para construir ferramentas com Open Cloud APIs for data stores para cumprir suas necessidades de operação. As seguintes exemplações mostram os processos de construção de um portal de inventário de usuário em Python com armazenamento de dados padrão e uma Exterior Persistente Leaderboard usando armazenamentos de dados ordenados.
Portal de Suporte ao Inventário do Usuário
Esta seção fornece um exemplo concreto de construir um portal de suporte de inventário de usuários em Python, no qual você pode listar e ler um subconjunto do inventário de seus usuários, fazer edições e, em seguida, atualizar de volta para o armazenamento de dados de uma experiência.
Para este exemplo, assuma o seguindo:
O nome do armazenamento de dados que armazena o inventário do usuário é Inventory .
O esquema de dados para cada entrada de dados é "userId": {"currency": number, "weapon": string, "level": number} . A chave é apenas userId .
O script Python lista um subconjunto de inventários de usuários com base em prefixos, aumenta sua moeda virtual em 10 para uma promoção e atualiza os dados.
De um nível alto, você pode construir seu aplicativo Python adicionando permissões de chave API e depois adicionando scripts.
Adicionando Permissões de Chave da API para Armazenamentos de Dados
Ao criar uma Chave da API para este exemplo, verifique se você executou as seguintes configurações:
Do menu Selecionar Sistema de API no menu Acessar Permissões , selecione armazenamento de universo .
(Opcional) In the Armazenamento de Dados section, select API operations for specific data stores.
- Habilite a Operações de Armazenamento de Dados Específicas alternar. Por padrão, cinco armazenamentos de dados são carregarautomaticamente, mas você pode adicionar armazenamentos de dados adicionais através do botão Adicionar Armazenamento de Dados à Lista.
- Selecione a seta suspensa ao lado do nome de um lojade dados, então selecione as operações de API que você deseja que o armazenamento de dados tenha acesso.
Selecione operações de API para toda a experiência.
- Clique no menu suspenso Selecione Experiência para Adicionar e selecione uma experiência.
- Na Experiência Operações , clique na seta suspensa e selecione as operações que você deseja adicionar à sua API (Interface de Programação para Aplicações). Este exemplo seleciona Leitura de entrada , Atualização de entrada e 1> Lista de entradas-chaves1> para a experiência inteira.
Você não precisa da permissão da chave da API create entries , pois o aplicativo não cria novos inventários de usuários.
Na seção Segurança , configure acesso IP explicito à chave usando Notação CIDR e configure uma data de expiração explícita para que sua chave pare de funcionar automaticamente após essa data. Para este exemplo, se você planeja fazer testes locais primeiro, você pode remover a restrição IP definindo-a para 0.0.0.0/0 e de
Adicionando Scripts para o Portal de Suporte ao Inventário do Usuário
Depois de criar a chave API com permissões necessárias para o exemplo de aplicativo, você precisa adicionar scripts de Python para executar as funcionalidades do app. O arquivo data_stores_methods.py mostra como definir <
data_stores_methodos.py
import hashlib
import requests
import json
import base64
class DataStores:
def __init__(self):
self._base_url = "https://apis.roblox.com/datastores/v1/universes/{universeId}"
# A chave da API é salva em uma variável de ambiente chamada 'API_KEY'
self._apiKey = str(os.environ['API_KEY'])
self._universeId = "UNIVERSE_ID"
self.ATTR_HDR = 'Roblox-entry-Attributes'
self.USER_ID_HDR = 'Roblox-entry-UserIds'
self._objects_url = self._base_url +self._universeId+'/standard-datastores/datastore/entries/entry'
self._increment_url = self._objects_url + '/increment'
self._version_url = self._objects_url + '/versions/version'
self._list_objects_url = self._base_url +self._universeId+'/standard-datastores/datastore/entries'
def _H(self):
return { 'x-api-key' : self._apiKey }
def _get_url(self, path_format: str):
return f"{self._config['base_url']}/{path_format.format(self._config['universe_id'])}"
return r, attributes, user_ids
def get_entry(self, datastore, object_key, scope = None):
self._objects_url = self._base_url +self._universeId+'/standard-datastores/datastore/entries/entry'
headers = { 'x-api-key' : self._apiKey }
params={"datastoreName" : datastore, "entryKey" : object_key}
if scope:
params["scope"] = scope
r = requests.get(self._objects_url, headers=headers, params=params)
if 'Content-MD5' in r.headers:
expected_checksum = r.headers['Content-MD5']
checksum = base64.b64encode(hashlib.md5(r.content).digest())
#print(f'Expected {Expected_checksum}, got {checksum})
attributes = None
if self.ATTR_HDR in r.headers:
attributes = json.loads(r.headers[self.ATTR_HDR])
user_ids = []
if self.USER_ID_HDR in r.headers:
user_ids = json.loads(r.headers[self.USER_ID_HDR])
return r
def list_entries(self, datastore, scope = None, prefix="", limit=100, allScopes = False, exclusive_start_key=None):
self._objects_url = self._base_url +self._universeId+'/standard-datastores/datastore/entries'
headers = { 'x-api-key' : self._apiKey }
r = requests.get(self._objects_url, headers=headers, params={"datastoreName" : datastore, "scope" : scope, "allScopes" : allScopes, "prefix" : prefix, "limit" : 100, "cursor" : exclusive_start_key})
return r
def increment_entry(self, datastore, object_key, incrementBy, scope = None, attributes=None, user_ids=None):
self._objects_url = self._base_url +self._universeId+'/standard-datastores/datastore/entries/entry/increment'
headers = { 'x-api-key' : self._apiKey, 'Content-Type': 'application/octet-stream' }
params={"datastoreName" : datastore, "entryKey" : object_key, "incrementBy" : incrementBy}
if scope:
params["scope"] = scope
r = requests.post(self._objects_url, headers=headers, params=params)
attributes = None
if self.ATTR_HDR in r.headers:
attributes = json.loads(r.headers[self.ATTR_HDR])
user_ids = []
if self.USER_ID_HDR in r.headers:
user_ids = json.loads(r.headers[self.USER_ID_HDR])
return r
update_inventory
Para testar, configure a variável de ambiente API_KEY e execute o arquivo update_inventory:
Leaderboard Persistente Externo
Esta seção apresenta um exemplo concreto de como criar uma tabela de classificação persistente externa no Python, na qual você pode listar e ler as informações do usuário armazenadas em armazenamentos de dados ordenados, fazer edições e, em seguida, publicar em um site externo para promoção.
Para este exemplo, assuma o seguindo:
O código de exemplo cria uma lista predefinida de nomes de usuário para o propósito de demonstração. Para sua própria aplicação, você deve usar a lista de usuários reais em sua experiência.
O código de exemplo adiciona 50 pontos a cada usuário que se juntar à experiência para o propósito de demonstração. Para sua própria aplicação, você deve definir a regra com base no design da experiência.
De um nível alto, você pode construir seu aplicativo Python adicionando permissões de chave API e depois adicionando scripts.
Adicionando Permissões de Chave da API para Armazenamentos de Dados Ordenados
O aplicativo de exemplo requer quatro métodos para alcançar suas funcionalidades: List Create 0> Update0> 1> 2> Increment2> e 5> 6> Increment6>, então você precisa adicionar as seguintes permissões da API:
- Leia para o método list.
- Escreva para Create , Update e 0> Increment0> métodos.
Ao criar uma Chave da API para este exemplo, verifique se você está executando as seguintes operações:
Do menu Selecionar Sistema de API na seção Permissões de Acesso , selecione Armazenamento de Dados Ordenados .
Adicionar permissões de operações de API para ler e escrever armazenamentos de dados ordenados na experiência do usuário.
- Clique no menu suspenso Selecione Experiência para Adicionar e selecione a experiência alvo.
- Na Experiência de Operações , expanda o menu suspenso para selecionar Leitura e Escrita operações.
Na seção Segurança , configure acesso IP explicito à chave usando Notação CIDR e configure uma data de expiração explícita para que sua chave pare de funcionar automaticamente após essa data. Para este exemplo, se você planeja fazer testes locais primeiro, você pode remover a restrição IP definindo-a para 0.0.0.0/0 e de
Adicionando Scripts para a Tabela de Líderes
Depois de criar a chave da API com permissões necessárias para o exemplo de aplicativo, você precisa adicionar scripts de Python para executar as funcionalidades do aplicativo.
O arquivo ordered_data_stores.py mostra
ordered_data_stores.py
import hashlib
import requests
import json
class DataStores:
def __init__(self, config_file):
with open(config_file) as f:
self._config = json.load(f)
def _H(self):
return { 'x-api-key' : self._config["api_key"], 'Content-Type': 'application/json'}
def _get_url(self, path_format: str):
return f"{self._config['base_url']}/{path_format.format(self._config['universe_id'])}"
def list(self, datastore, scope, pageSize = 10, orderBy = "", filter = "", exclusiveStartKey = ""):
self._objects_url = self._config['api_key_url']+"universes/"+self._config["universe_id"]+"/orderedDataStores/"+datastore+"/scopes/"+scope+"/entries"
headers = { 'x-api-key' : self._config["api_key"] }
r = requests.get(self._objects_url, headers=headers, params={"max_page_size": pageSize, "order_by" : orderBy, "filter" : filter, "page_token" : ""})
return r
def create(self, datastore, scope, entry, data):
self._objects_url = self._config['api_key_url']+"universes/"+self._config["universe_id"]+"/orderedDataStores/"+datastore+"/scopes/"+scope+"/entries"
headers = self._H()
payload = json.dumps({
"value": 11
})
return requests.post(self._objects_url, params = {"id": entry }, data=payload, headers=headers)
def increment(self, datastore, scope, entry, incrementBy):
self._objects_url = self._config['api_key_url']+"universes/"+self._config["universe_id"]+"/orderedDataStores/"+datastore+"/scopes/"+scope+"/entries/"+entry+":increment"
headers = { 'x-api-key' : self._config["api_key"] }
payload = json.dumps({
"amount": 1
})
r = requests.post(self._objects_url, headers=headers, data=payload)
return r
classificação.py
configurar
{
"universe_id": "",
"api_key_url": "https://apis.roblox.com/datastores/ordered-v1/",
"api_key": ""
}
Para testar, configure a variável de ambiente API_KEY e execute o arquivo leaderboard:
Depois de completar o teste, você pode publicar ou embuter o placar de classificação em sites fora do Roblox para mais alcance.