Oprócz dostępu do magazynów danych używając Lua DataStoreService na serwerach Studio lub na żywych serwerach, możesz używać Open Cloud API, aby uzyskać dostęp i wykorzystać Standardowe i 2>zamówione2> magazyny danych z zewnętrznych skryptów i narzędzi z granularnym dostędem i kontrolą bezpieczeństwa.
Otwarty Cloud API dla przechowywanych danych są API, które mogą być przedmiotem zmian w przyszłości.
Użyj
Możesz poprawić kilka obszarów swojego workflow'u poprzez dostęp do swoich danych za pomocą tych API, takich jak:
Portal wsparcia klienta : Przechowywanie danych jest użyteczne do przechowywania trwałych zasobów użytkownika, takich jak przedmioty w ekwipunku użytkownika lub punkty umiejętności. Czasami musisz aktualizować te zasoby dla celów dział wsparcia klientówklienta. Zamiast używania Studio lub dołączenia do doświadczenia za każdym razem, gdy otwierasz, możesz zbudowa
Panel główny LiveOps : Możesz zbudować panel główny LiveOps używając API, aby poprawić wydajność operacji na żywo, takich jak rozpisywanie wydarzeń w doświadczeniu. Możesz kodować wydarzenie z wyprzedzeniem, ukrywać go pod flagą funkcji jako część danych konfiguracyjnych w magazynie danych i ustawić czas na zmianę flagi do publikacji wydarzenia. Twoje
Eksternal Leaderboard : Aby promować swoje doświadczenia poza Roblox, możesz wyciągnąć informacje o swoim doświadczeniu, takie jak tabela liderów w wyścigu, w czasie rzeczywistym i wyświetlić je na zewnętrznej stronie internetowej. Możesz udzielić dostępu tylko do czytalnego dla twoich zasobów zewnętrznych stron internetowych poprzez HTTP i aktualizować stronę internet
Automatyzacja migracji danych : Dane mogą się zmieniać lub aktualizować, gdy twoje doświadczenie ewoluuje, takie jak aktualizacja schem danych, aby zmieścić nowe funkcje. Aby uniknąć utraty istniejących danych użytkownika, czasami musisz przenieść swoje magazyny danych z starego schemu na nowy. Możesz napisać zewnętrz
Różnice z API Lua
Chociaż API Open Cloud są podobne do Lua DataStoreService , istnieje kilka różnych wymagań, aby uważać:
ID i nazwa magazynu danych w wersji Open Cloud : W przeciwieństwie do interfejsu Lua API, Open Cloud APIs są stateless i mogą pochodzić z dowolnego źródła, więc zawsze musisz zapewnić ID Universe , unikalny identyfikator swojego doświadczenia, i nazwę Cloud AP przy wysyłaniu zgłoszeń. Dla więcej inform
Dla tworzenia i aktualizacji oddzielne uprawnienia : Lua API tworzy nowe wpisy, jeśli nie istnieją, gdy wezwiesz DataStore:SetAsync() , ale metody Open Cloud do tworzenia i aktualizacji wpisów są osobne. Dla przykładu możesz stworzyć narzędzie wsparcia klienta, które może edytować profil istniejącego u
Serializacja danych : Wszystkie otwarte punkty końcowe w chmurze wymagają od Siebie serjalizacji wszystkich danych przed siecią transportową. Serializacja oznacza konwersję obiektu w tę ciąg, a deseryfikacja jest jego przeciwieństwem (konwersja stronki w obiekt). Lua API serjalizuje i deseryfikuje treści wpisu automatycznie, ale dla otwartej chmury musisz gener
Dostępy bezpieczeństwa
Przechowywanie danych zwykle przechowuje wrażliwe informacje, takie jak profile użytkowników i wirtualna waluta. Aby utrzymać bezpieczeństwo, każda witryna API ma odpowiadające wymagane uprawnienia, które musisz dodać do swojego klucza API, takie jak uprawnienia List Keys dla witryny API. Jeś
Gdy konfigurujesz klucze API, możesz ustawić granularne uprawnienia, takie jak czytanie, przeczytanei listowanie pozycji, dla każdego magazynu danych w określonym doświadczeniu, lub możesz dać klucz do czytania lub pisania wszystkich magazynów danych w określonym doświadczeniu. Możesz również ograniczyć dostęp do poddz
Narzędzia budowania
Możesz użyć języka swojego wyboru, aby budować narzędzia za pomocą otwartych chmurowych API do przechowywania danych, aby spełnić swoje potrzeby operacyjne. Poniższe przykłady przechodzą przez procesy budowy portalu eksportowego w Pythonie z użyciem standardowych magazynów danych i dysków zewnętrznych używając zasobów sortowanych.
Portal wsparcia dla ekwipunku użytkownika
Ten sekcja dostarcza konkretny przykład budowy portalu wsparcia ekwipunku użytkownika w Python, w którym możesz zalistować i przeczytać podzespół wyposażenieużytkownika, zrobić edytje i następnie zaktualizować do przechowywania danych sklep.
Dla tego przykładu załóż, obserwuje:
Nazwa magazynu danych, w którym przechowywana jest ekwipunek użytkownika, to Inventory.
Schemat danych dla każdej pozycji danych jest "userId": {"currency": number, "weapon": string, "level": number} . Klucz to po prostu userId .
Skrypt Python listuje podzespół ekwipunków użytkownika w oparciu o przedrostki, zwiększ ich wirtualną walutę o 10 dla promocjai aktualizacji danych.
Z wysokiego poziomu możesz zbudować swoją aplikację Python, dodając do niej uprawnienia do klucza API i następnie dodając skrypciny.
Dodawanie uprawnień API dla przechowywania danych
Podczas tworzenia klucza API dla tego przykładu upewnij się, że wykonujesz następujące ustawienia:
Z menu Wybierz system API w sekcji Dostęp upoważnionych , wybierz uniwersalne magazyny danych .
(Opcjonalne) W sekcji Przechowywanie danych wybierz operacje API dla konkretnych przechowywanych danych.
- Włącz Specjalne Pracowania magazynowe danych przełącznik. Domyślnie pięć magazynów danych automatycznie wczytywać, ale możesz dodać dodatkowe magazyny danych poprzez przycisk Dodaj nowy magazyn danych .
- Wybierz menu rozwinięte obok nazwy sklepdanych, a następnie wybierz operacje API, do których chcesz, aby mieć dostęp magazyn danych.
Wybierz operacje API dla całego doświadczenia.
- Kliknij Wybierz doświadczenie do dodania pasek rozsuwu i wybierz doświadczenie.
- W Operacje doświadczenia , kliknij strzałkę menu i wybierz operacje, które chcesz dodać do swojej API. Ten przykład wybiera Czytaj wejście , Aktualizuj wejście i 1> Listuj klucze wpisu1> dla całego doświadczenia.
Nie potrzebujesz API klucza create entries, ponieważ aplikacja nie tworzy nowych ekwipunków użytkowników.
W sekcji Bezpieczeństwo, wyraźnie ustaw ustawienia dostępu IP do klucza używając notacji CIDR , a ustaw datę wygaszaния wyraźnie, aby klucz automatycznie przestał działać po tej dacie. Dla tego przykładu, jeśli planujesz przeprowadzić lokalne testy najpierw, mo
Dodawanie Skryptów do Portalu Wsparcia dla Użytkowników
Po utworzeniu klucza API wymaganego dla przykładowego aplikacja, musisz dodać skrypcity Python, aby wykonać funkcje aplikacji. Plik data_stores_methods.py pokaz
data_stores_methods.pl
import hashlib
import requests
import json
import base64
class DataStores:
def __init__(self):
self._base_url = "https://apis.roblox.com/datastores/v1/universes/{universeId}"
# Klucz API jest zapisany w zmiennej środowiskowej oznaczającej „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
aktualizuj_inventarz
Aby przetesterować, ustaw zmienną środowiskową API_KEY i wykonaj plik update_inventory :
Z zewnętrznym, trwałym liderboard
Ten dział przejścia przez konkretny przykład tworzenia zewnętrznej trwałej listy liderów w Pythonie, w której możesz spisać i czytać informacje o użytkownikach przechowywane w przechowywanych danych, dokonywać edytji i następnie opublikować na zewnętrznej stronie internetowej do promocja.
Dla tego przykładu załóż, obserwuje:
Przykładowy kod tworzy listę ustawionych nazw użytkowników dla celów demonstracji. Dla własnej aplikacji powinieneś użyć listy rzeczywistych użytkowników w swoim doświadczeniu.
Przykładowy kod dodaje 50 punktów do każdego użytkownika dołączającego do doświadczenia w celach demonstracyjnych. Dla własnej aplikacji powinieneś zdefiniować zasadę w oparciu o projekt doświadczenia.
Z wysokiego poziomu możesz zbudować swoją aplikację Python, dodając do niej uprawnienia do klucza API i następnie dodając skrypciny.
Dodanie upoważnień API dla przechowywanych danych
Przykładowa aplikacja wymaga czterech metod, aby osiągnąć jej funkcjonalności: List , Create , 0> Update0> 0> i 2> 5> 6> Increment6>, więc musisz dodać następujące
- Przeczytaj dla metody list .
- Napisz dla Create , Update i 0> Increment0> metod.
Podczas tworzenia klucza API dla tego przykładu upewnij się, że wykonujesz następujące operacje:
Z menu Wybierz system API w sekcji Dostęp upoważnionych danych , wybierz Przechowywane dane zlecone .
Dodaj uprawnienia API do czytania i zapisywania uproszczonych przechowywanych danych w celu doświadczenia docelowego.
- Kliknij Wybierz doświadczenie do dodania pasek rozsuwu i wybierz doświadczenie docelowe.
- W Operacjach doświadczeń rozwinięto menu rozwijanego, aby wybrać Czytaj i Pisać operacje.
W sekcji Bezpieczeństwo, wyraźnie ustaw ustawienia dostępu IP do klucza używając notacji CIDR , a ustaw datę wygaszaния wyraźnie, aby klucz automatycznie przestał działać po tej dacie. Dla tego przykładu, jeśli planujesz przeprowadzić lokalne testy najpierw, mo
Dodawanie Skryptów do Tabeli Liderów
Po utworzeniu klucza API wymaganymi dla przykładowego aplikacja, musisz dodać skrypcity Python, aby wykonać funkcje aplikacji.
Plik ordered_data_stores.py pokazuje,
ordered_data_stores.pl
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
ranking.py
konfiguruj
{
"universe_id": "",
"api_key_url": "https://apis.roblox.com/datastores/ ordered-v1/",
"api_key": ""
}
Aby przetesterować, ustaw zmienną środowiskową API_KEY i wykonaj plik leaderboard :
Po zakończeniu testu możesz opublikować lub wbudować tabelę liderów na stronach zewnętrznych Roblox, aby uzyskać więcej zasięgu.