Además de acceder a almacenes de datos usando Lua DataStoreService en Studio o servidores en vivo, puede usar las API de Open Cloud para acceder y utilizar datos estándar y 2>almacenes de datos ordenados2> de fuentes y herramientas con control de acceso y seguridad granulares.
Las API de Open Cloud para almacenes de datos son API beta que podrían estar sujetas a cambios en futuras versiones.
Uso
Puede mejorar varias áreas de su flujo de trabajo al acceder a sus datos con estas API, como:
Portal de soporte del cliente : Los almacenes de datos son útiles para almacenar recursos de usuario persistentes, como artículos en los inventarios de los usuarios o puntos de habilidad. A veces es necesario actualizar estos recursos para el Soportedel cliente. En lugar de usar Studio o unirse a una experiencia cada vez que se actualiza manualmente, puede construir una aplicación web para permitir que sus agentes de servicio al cliente manejen directamente las solicitudes de soporte del cliente, como ver
Panel de LiveOps : Puedes construir un panel de LiveOps usando las API para mejorar la eficiencia de las operaciones en vivo, como la programación de eventos in experiencia. Puedes codificar un evento con anticipación, ocultarlo debajo de una bandera de función como parte de los datos de configuración en un tiendade datos y establecer un tiempo para cambiar la bandera para publicar el evento. Tus servidores de experiencia pueden detectar este cambio leyendo la bandera para
Tabla de clasificación externa : Para promocionar tus experiencias fuera de Roblox, puedes extraer la información de tu experiencia, como la tabla de clasificación de una carrera, en tiempo real y mostrarla en un sitio web externo. Puedes conceder el acceso de solo lectura a tus almacenes de datos ordenados para que el sitio web solicite periódicamente los datos más recientes a través de HTTP y actualice la página web.
Automatización de migración de datos : Los datos pueden cambiar o actualizarse a medida que tu experiencia evoluciona, como actualizar los esquemas de datos para aceptar nuevas características. Para evitar perder datos existentes, a veces es necesario migrar tus almacenes de datos desde el viejo esquema a un nuevo. Puedes escribir un script externo que lea cada entrada de los almacenes de datos actuales, mapa los datos en el
Diferencias con la API de Lua
Aunque las API de Open Cloud son similares a la Lua DataStoreService , hay algunos requisitos diferentes de los que debe estar al tanto:
ID del universo y nombre del almacén de datos : a diferencia de la API Lua, las API de Open Cloud son estáticas y se pueden provenir de cualquier lugar, por lo que siempre debe proporcionar el ID del universo , el identificador único de su experiencia, y el nombre del almacén cuando envía las solicitudes . Para obtener más información sobre cómo obtener un ID de universo, consulte 0> Universo
Permisos separados para crear y actualizar : La API Lua crea nuevas entradas si no existen cuando llamas a DataStore:SetAsync() , pero los métodos Open Cloud para crear y actualizar entradas son separados. Los permisos separados pueden ser más seguros y más flexibles en algunas situaciones. Por ejemplo, puedes crear una herramienta de soporte de clientes que puede editar el perfil de un usuario existente
serialización de datos : Todos los puntos de finalización de Open Cloud requieren que todos los datos se serialicen antes de que se envíen a través de la red. La serialización significa convertir un objeto en ese cadena, y la deserialización es su operación opuesta (conversar un valor en un objeto). La API Lua serializa y deserializa el contenido de entrada automáticamente, pero para Open Cloud es necesario generar o procesar los datos de entrada con JSON por su en posesióncuenta.
Permisos de seguridad
Los almacenes de datos generalmente almacenan información sensible, como perfiles de usuarios y moneda virtual. Para mantener la seguridad, cada API de Open Cloud tiene permisos de acceso correspondientes que debe agregar a su clave de API, como el permiso de List Keys para la lista de API. Si no agrega los permisos requeridos, su llamada de API devuelve un error. Para las especificaciones de permisos
Cuando Configurar las llaves de tu API, puedes establecer permisos granulares, como leído, escribir y listar entrada, para cada almacén de datos dentro de una experiencia específica, o puedes darle una llave para leer o escribir todos los almacenes de datos dentro de una experiencia. También puedes limitar el acceso a un subconjunto de almacenes de datos necesarios para tu herramienta en lugar de exponer todos los almacenes de datos. Esto mit
Herramientas de construcción
Puede usar el lenguaje de su elección para construir herramientas con Open Cloud APIs for data stores para cumplir con sus necesidades de operación. Las siguientes例子 walk through the processes of building a inventario de usuario soporte portal in Python con estándar de almacenamiento de datos y un Exterior persistente leaderboard using ordered data stores.
Portal de soporte de inventario del usuario
Esta sección proporciona un ejemplo concreto de cómo construir un portal de soporte de inventario de usuarios en Python, en el que puedes listar y leer un subconjunto del inventario de tus usuarios, hacer ediciones y luego actualizar de vuelta a la tienda de datos de una experiencia.
Para este ejemplo, asumamos lo siguiendo:
El nombre del almacén de datos que almacena el inventario del usuario es Inventory .
El esquema de datos para cada entrada de datos es "userId": {"currency": number, "weapon": string, "level": number} . La clave es solo userId .
El script de Python lista un subconjunto de inventarios de usuarios basado en los sufijos, aumenta su moneda virtual en 10 para una promoción y actualiza los datos.
Desde un nivel alto, puede construir su aplicación de Python agregando permisos de clave de API y luego agregando scripts.
Agregar permisos de API para almacenes de datos
Al crear una llave de API para este ejemplo, asegúrese de realizar las siguientes configuraciones:
Del menú Seleccionar sistema de API en la sección Acceso a permisos , seleccione almacenes de datos universos .
(Opcional) En la sección Almacenes de datos , seleccione operaciones de API para almacenes de datos específicos.
- Habilita el Almacenamiento de Datos Específico botón. Por defecto, cinco almacenes de datos se cargarautomáticamente, pero puede agregar almacenes de datos adicionales a través del botón Añadir Almacén de Datos a la Lista .
- Seleccione la flecha desplegable junto al nombre de un tiendade datos, luego seleccione las operaciones de API que desea que tenga el almacén de datos.
Seleccione operaciones de API para toda la experiencia.
- Haga clic en el menú desplegable Seleccione la experiencia para agregar y seleccione una experiencia.
- En el Operaciones de Experiencia, haz clic en la flecha desplegable y selecciona las operaciones que quieres agregar a tu API. Este ejemplo selecciona Leer entrada, Actualizar entrada y 2> Listar entradas de clave2> para toda la experiencia.
No necesitas la autorización de la API create entries ya que la aplicación no crea nuevos inventarios de usuarios.
En la sección Seguridad , configura explícitamente el acceso IP a la clave usando la notación CIDR , y establece una fecha de caducidad explícita para que tu clave deje de funcionar automáticamente después de esa fecha. Para este ejemplo, si planeas hacer una prueba local primero, puedes eliminar la restricción IP al establecerla en 0.0.0
Agregar Scripts para el Portal de Soporte del Inventario del Usuario
Después de crear la llave de API con permisos requeridos para la aplicación (app)de ejemplo, debe agregar scripts de Python para realizar las funcionalidades de la aplicación. El archivo data_stores_methods.py muestra có
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}"
# La clave de API se guarda en una variable de entorno llamada '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}, obtuviste {checknum})
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
actualizar inventario
Para probar, establezca la variable de entorno API_KEY y ejecute el archivo update_inventory :
Tabla de clasificación persistente externa
Esta sección muestra un ejemplo concreto de cómo crear una tabla de clasificación persistente externa en Python, en la que puedes listar y leer la información de los usuarios almacenada en almacenes de datos ordenados, hacer ediciones y luego publicar en un sitio web externo para promoción.
Para este ejemplo, asumamos lo siguiendo:
La muestra de código crea una lista predeterminada de nombres de usuarios para el propósito de la demostración. Para su propia aplicación, debe usar la lista de usuarios reales en su experiencia.
La muestra de código añade 50 puntos a cada usuario que se une a la experiencia para el propósito de la demostración. Para tu propia aplicación, deberás definir la regla en función del diseño de tu experiencia.
Desde un nivel alto, puede construir su aplicación de Python agregando permisos de clave de API y luego agregando scripts.
Agregar permisos de API para almacenes de datos ordenados
La aplicación de ejemplo requiere cuatro métodos para lograr sus funcionalidades: List , 1> Create1> , 4> 5> Update5> y 7> 8> Increment8>, por lo que debe agregar las siguientes autorizaciones de API:
- Leer para el método list .
- Escriba para Create , Update y 0>incrementar0> métodos.
Al crear una llave de API para este ejemplo, asegúrese de realizar las siguientes operaciones:
Del menú Seleccionar sistema de API en la sección Acceso a permisos , seleccione Almacenamiento de datos ordenados .
Añade permisos de operaciones de API para leer y escribir almacenamientos de datos ordenados en la experiencia de destino.
- Haga clic en el menú desplegable Seleccione la experiencia para agregar y seleccione la experiencia objetivo.
- En la Operaciones de Experiencia , expanda el menú desplegable para seleccionar Leer y Escribir operaciones.
En la sección Seguridad , configura explícitamente el acceso IP a la clave usando la notación CIDR , y establece una fecha de caducidad explícita para que tu clave deje de funcionar automáticamente después de esa fecha. Para este ejemplo, si planeas hacer una prueba local primero, puedes eliminar la restricción IP al establecerla en 0.0.0
Agregar Scripts para el Tablero de Clasificación
Después de crear la llave de API con permisos requeridos para la aplicación (app)de ejemplo, debe agregar scripts de Python para realizar las funcionalidades de la aplicación.
El clasificaciónordered_data_stores.py muestra có
ordenado_datos_almacenados.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
clasificación.py
configurar
{
"universe_id": "",
"api_key_url": "https://apis.roblox.com/datastores/ordenado-v1/",
"api_key": ""
}
Para probar, establezca la variable de entorno API_KEY y ejecute el archivo leaderboard :
Después de completar la prueba, puede publicar o incrustar la tabla de clasificación en sitios web fuera de Roblox para obtener más alcance.