Krótkie wprowadzenie do wdrożenia pamięci współdzielonej i agregacji prywatnej

Ten dokument to krótki przewodnik po korzystaniu z Shared Storage i Private Aggregation. Musisz znać oba interfejsy API, ponieważ Shared Storage przechowuje wartości, a Private Aggregation tworzy raporty, które można agregować.

Grupa odbiorców: dostawcy technologii reklamowych i usług pomiarowych.

Interfejs Shared Storage API

Aby zapobiegać śledzeniu w witrynach, przeglądarki zaczęły dzielić wszystkie formy pamięci, w tym pamięć lokalną, pliki cookie itp. Istnieją jednak przypadki użycia, w których wymagana jest niepodzielona pamięć. Interfejs Shared Storage API zapewnia nieograniczony dostęp do zapisu w różnych witrynach najwyższego poziomu z zachowywaniem prywatności i dostępem do odczytu.

Dostęp do pamięci współdzielonej jest ograniczony do źródła kontekstu (wywołującego interfejs sharedStorage).

Pamięć współdzielona ma limit pojemności dla każdej domeny, a każdy wpis jest ograniczony do maksymalnej liczby znaków. Po osiągnięciu limitu nie są zapisywane żadne kolejne dane wejściowe. Limity miejsca na dane są opisane w wyjaśnieniu dotyczącym Shared Storage.

Wywoływanie Shared Storage

Technologie reklamowe mogą zapisywać dane w pamięci współdzielonej za pomocą JavaScriptu lub nagłówka odpowiedzi. Odczyt z pamięci współdzielonej odbywa się tylko w izolowanym środowisku JavaScript o nazwie worklet.

• Używanie JavaScriptu: technologie reklamowe mogą wykonywać określone funkcje pamięci współdzielonej, takie jak ustawianie, dołączanie i usuwanie wartości poza elementem roboczym JavaScriptu. Funkcje takie jak odczytywanie Shared Storage i wykonywanie Private Aggregation muszą być jednak realizowane za pomocą workletu JavaScript. Metody, których można używać poza procesem roboczym JavaScript, znajdziesz w sekcji Proposed API Surface - Outside the worklet (Proponowana powierzchnia interfejsu API – poza procesem roboczym).

  Metody używane w worklecie podczas operacji znajdziesz w sekcji Proponowany interfejs API – w sekcji worklet.

• Korzystanie z nagłówków odpowiedzi

  Podobnie jak w przypadku JavaScriptu, za pomocą nagłówków odpowiedzi można wykonywać tylko określone funkcje, takie jak ustawianie, dołączanie i usuwanie wartości w pamięci współdzielonej. Aby korzystać z pamięci współdzielonej w nagłówku odpowiedzi, w nagłówku żądania musi być zawarty parametr Shared-Storage-Writable: ?1.

  Aby zainicjować żądanie z poziomu klienta, uruchom ten kod w zależności od wybranej metody:

  • Jak korzystać z aplikacji fetch()

    fetch("https://a.example/path/for/updates", {sharedStorageWritable: true});
    

  • Używanie tagu iframe lub img

    <iframe src="https://a.example/path/for/updates" sharedstoragewritable></iframe>
    

  • Używanie atrybutu IDL z tagiem iframe lub img

    let iframe = document.getElementById("my-iframe");
    iframe.sharedStorageWritable = true;
    iframe.src = "https://a.example/path/for/updates";
    

Więcej informacji znajdziesz w artykule Pamięć współdzielona: nagłówki odpowiedzi.

Zapisywanie w pamięci współdzielonej

Aby zapisać dane w pamięci współdzielonej, wywołaj funkcję sharedStorage.set() wewnątrz lub na zewnątrz workletu JavaScript. Jeśli wywołanie nastąpi spoza workletu, dane zostaną zapisane w źródle kontekstu przeglądania, z którego nastąpiło wywołanie. Jeśli wywołanie nastąpi z poziomu workletu, dane zostaną zapisane w źródle kontekstu przeglądania, który załadował worklet. Ustawione klucze wygasają po 30 dniach od ostatniej aktualizacji.

Pole ignoreIfPresent jest opcjonalne. Jeśli ten tag jest obecny i ma wartość true, klucz nie jest aktualizowany, jeśli już istnieje. Okres ważności klucza jest odnawiany do 30 dni od wywołania funkcji set(), nawet jeśli klucz nie jest aktualizowany.

Jeśli dostęp do pamięci współdzielonej jest uzyskiwany wielokrotnie podczas tego samego ładowania strony z tym samym kluczem, wartość klucza jest zastępowana. Warto użyć wartości sharedStorage.append(), jeśli klucz ma zachować poprzednią wartość.

• Korzystanie z JavaScriptu

  Poza komponentem:

  window.sharedStorage.set('myKey', 'myValue1', { ignoreIfPresent: true });
  // Shared Storage: {'myKey': 'myValue1'}
  window.sharedStorage.set('myKey', 'myValue2', { ignoreIfPresent: true });
  // Shared Storage: {'myKey': 'myValue1'}
  window.sharedStorage.set('myKey', 'myValue2', { ignoreIfPresent: false });
  // Shared Storage: {'myKey': 'myValue2'}
  

  Podobnie w przypadku workletu:

  sharedStorage.set('myKey', 'myValue1', { ignoreIfPresent: true });
  

• Korzystanie z nagłówków odpowiedzi

  Możesz też zapisywać dane w pamięci współdzielonej za pomocą nagłówków odpowiedzi. Aby to zrobić, użyj w nagłówku odpowiedzi tagu Shared-Storage-Write wraz z tymi poleceniami:

  Shared-Storage-Write : set;key="myKey";value="myValue";ignore_if_present
  

  Shared-Storage-Write : set;key="myKey";value="myValue";ignore_if_present=?0
  

  Poszczególne elementy mogą być oddzielone przecinkami i mogą łączyć set, append, delete i clear.

  Shared-Storage-Write :
  set;key="hello";value="world";ignore_if_present, set;key="good";value="bye"
  

Dołączanie wartości

Możesz dodać wartość do istniejącego klucza za pomocą metody append. Jeśli klucz nie istnieje, wywołanie append() spowoduje jego utworzenie i ustawienie wartości. Możesz to zrobić za pomocą JavaScriptu lub nagłówka odpowiedzi.

• Korzystanie z JavaScriptu

  Aby zaktualizować wartości istniejących kluczy, użyj sharedStorage.append() w worklecie lub poza nim.

  window.sharedStorage.append('myKey', 'myValue1');
  // Shared Storage: {'myKey': 'myValue1'}
  window.sharedStorage.append('myKey', 'myValue2');
  // Shared Storage: {'myKey': 'myValue1myValue2'}
  window.sharedStorage.append('anotherKey', 'hello');
  // Shared Storage: {'myKey': 'myValue1myValue2', 'anotherKey': 'hello'}
  

  Aby dołączyć dane w worklecie:

  sharedStorage.append('myKey', 'myValue1');
  

• Korzystanie z nagłówków odpowiedzi

  Podobnie jak w przypadku ustawiania wartości w pamięci współdzielonej, możesz użyć nagłówka odpowiedzi Shared-Storage-Write, aby przekazać parę klucz-wartość.

  Shared-Storage-Write : append;key="myKey";value="myValue2"
  

Zbiorcze aktualizowanie wartości

Możesz wywołać funkcję sharedStorage.batchUpdate() w worklecie JavaScript lub poza nim i przekazać uporządkowaną tablicę metod określających wybrane operacje. Każdy konstruktor metody akceptuje te same parametry co odpowiednia metoda indywidualna dla ustawiania, dołączania, usuwania i czyszczenia.

Możesz wywołać batchUpdate() z JavaScriptu lub użyć nagłówka odpowiedzi:

• Korzystanie z JavaScriptu

  Metody JavaScriptu, których można używać z batchUpdate():

  • SharedStorageSetMethod(): zapisuje parę klucz-wartość w pamięci współdzielonej.
  • SharedStorageAppendMethod(): dołącza wartość do istniejącego klucza w pamięci współdzielonej lub zapisuje parę klucz-wartość, jeśli klucz jeszcze nie istnieje.
  • SharedStorageDeleteMethod(): usuwa parę klucz-wartość z pamięci współdzielonej.
  • SharedStorageClearMethod(): czyści wszystkie klucze w pamięci współdzielonej.

  sharedStorage.batchUpdate([
  new SharedStorageSetMethod('keyOne', 'valueOne'),
  new SharedStorageAppendMethod('keyTwo', 'valueTwo'),
  new SharedStorageDeleteMethod('keyThree'),
  new SharedStorageClearMethod()
  ]);
  

• Korzystanie z nagłówków odpowiedzi

  Shared-Storage-Write : set;key=keyOne;value=valueOne, append;key=keyTwo;value=valueTwo,delete;key=keyThree,clear
  

Używanie nagłówków odpowiedzi powoduje wykonanie batchUpdate() dla wszystkich metod w nagłówku.

Odczytywanie z pamięci współdzielonej

Odczytywanie danych z pamięci Shared Storage jest możliwe tylko w worklecie.

await sharedStorage.get('mykey');

Pochodzenie kontekstu przeglądania, z którego załadowano moduł worklet, określa, czyja pamięć Shared Storage jest odczytywana.

Usuwanie z pamięci współdzielonej

Usuwanie danych z pamięci współdzielonej można przeprowadzać za pomocą kodu JavaScript w worklecie lub poza nim albo za pomocą nagłówków odpowiedzi z wartością delete(). Aby usunąć wszystkie klucze naraz, użyj clear().

• Korzystanie z JavaScriptu

  Aby usunąć dane z pamięci Shared Storage spoza workletu:

  window.sharedStorage.delete('myKey');
  

  Aby usunąć dane z Shared Storage z poziomu workletu:

  sharedStorage.delete('myKey');
  

  Aby usunąć wszystkie klucze naraz spoza workletu:

  window.sharedStorage.clear();
  

  Aby usunąć wszystkie klucze naraz z poziomu workletu:

  sharedStorage.clear();
  

• Korzystanie z nagłówków odpowiedzi

  Aby usunąć wartości za pomocą nagłówków odpowiedzi, możesz też użyć w nagłówku odpowiedzi parametru Shared-Storage-Write, aby przekazać klucz do usunięcia.

  delete;key="myKey"
  

  Aby usunąć wszystkie klucze za pomocą nagłówków odpowiedzi:

  clear;
  

Odczytywanie grup zainteresowań Protected Audience z pamięci współdzielonej

Możesz odczytywać grupy zainteresowań interfejsu Protected Audience z workletu pamięci współdzielonej. Metoda interestGroups() zwraca tablicę obiektów StorageInterestGroup, w tym atrybuty AuctionInterestGroup i GenerateBidInterestGroup.

Przykład poniżej pokazuje, jak odczytywać grupy zainteresowań w kontekście przeglądania i jakie operacje można wykonywać na pobranych grupach zainteresowań. Dwie możliwe operacje to znalezienie liczby grup zainteresowań i znalezienie grupy zainteresowań z największą liczbą stawek.

async function analyzeInterestGroups() {
  const interestGroups = await interestGroups();
  numIGs = interestGroups.length;
  maxBidCountIG = interestGroups.reduce((max, cur) => { return cur.bidCount > max.bidCount ? cur : max; }, interestGroups[0]);
  console.log("The IG that bid the most has name " + maxBidCountIG.name);
}

Pochodzenie kontekstu przeglądania, z którego załadowano moduł worklet, określa pochodzenie grup zainteresowań odczytywanych domyślnie. Więcej informacji o domyślnym pochodzeniu workletu i o tym, jak je zmienić, znajdziesz w sekcji Wykonywanie pamięci współdzielonej i prywatnej agregacji w przewodniku po interfejsie Shared Storage API.

Opcje

Wszystkie metody modyfikatora Shared Storage obsługują opcjonalny obiekt opcji jako ostatni argument.

withLock

Opcja withLock jest opcjonalna. Jeśli ta opcja jest określona, nakazuje metodzie uzyskanie blokady zdefiniowanego zasobu za pomocą interfejsu Web Locks API przed przejściem dalej. Podczas wysyłania prośby o zablokowanie przekazywana jest nazwa blokady. Nazwa reprezentuje zasób, którego użycie jest koordynowane na wielu kartach, w procesach lub kodzie w ramach źródła.

Opcja withLock może być używana z tymi metodami modyfikatora pamięci współdzielonej:

• zestaw
• dołączanie
• usuń
• wyczyść
• aktualizacja zbiorcza

Możesz ustawić blokadę za pomocą JavaScriptu lub nagłówka odpowiedzi:

• Korzystanie z JavaScriptu

  sharedStorage.set('myKey', 'myValue', { withLock: 'myResource' });
  

• Korzystanie z nagłówków odpowiedzi

  Shared-Storage-Write : set;key="myKey";value="myValue",options;with_lock="myResource"
  

Blokady pamięci współdzielonej są dzielone według pochodzenia danych. Blokady są niezależne od blokad uzyskanych za pomocą metody LockManager request(), niezależnie od tego, czy znajdują się w kontekście window czy worker. Mają jednak taki sam zakres jak blokady uzyskane za pomocą request() w kontekście SharedStorageWorklet.

Metoda request() umożliwia korzystanie z różnych opcji konfiguracji, ale blokady uzyskane w pamięci współdzielonej zawsze są zgodne z tymi ustawieniami domyślnymi:

• mode: "exclusive": nie można jednocześnie posiadać innych blokad o tej samej nazwie.
• steal: false: istniejące blokady o tej samej nazwie nie są zwalniane, aby uwzględnić inne żądania.
• ifAvailable: false: żądania czekają w nieskończoność, aż blokada stanie się dostępna.

Kiedy używać withLock

Blokady są przydatne w sytuacjach, gdy jednocześnie może działać wiele elementów roboczych (np. wiele elementów roboczych na stronie lub wiele elementów roboczych na różnych kartach), z których każdy analizuje te same dane. W takim przypadku warto otoczyć odpowiedni kod workletu blokadą, aby mieć pewność, że w danym momencie tylko jeden worklet przetwarza raporty.

Blokady są przydatne również wtedy, gdy w worklecie trzeba odczytać kilka kluczy, a ich stan powinien być zsynchronizowany. W takim przypadku wywołania get należy objąć blokadą i upewnić się, że podczas zapisywania danych w tych kluczach uzyskuje się tę samą blokadę.

Kolejność zamków

Ze względu na charakter blokad internetowych metody modyfikatorów mogą nie być wykonywane w zdefiniowanej przez Ciebie kolejności. Jeśli pierwsza operacja wymaga blokady i jest opóźniona, druga operacja może się rozpocząć, zanim pierwsza się zakończy.

Na przykład:

// This line might pause until the lock is available.
sharedStorage.set('keyOne', 'valueOne', { withLock: 'resource-lock' });

// This line will run right away, even if the first one is still waiting.
sharedStorage.set('keyOne', 'valueTwo');

Przykład modyfikowania wielu kluczy

Opcja withLock z batchUpdate() zapewnia wzajemne wykluczanie się z innymi równoczesnymi operacjami, które uzyskują to samo blokowanie. Opcję withLock możesz zastosować do batchUpdate() w przypadku całego pakietu. Zastosowanie withLock do dowolnego obiektu metody w partii powoduje zgłoszenie wyjątku.

W tym przykładzie używamy blokady, aby zapewnić, że operacje odczytu i usuwania w worklecie będą wykonywane razem, co zapobiega zakłóceniom z zewnątrz workletu.

W tym modify-multiple-keys.jsprzykładziekeyOne ustawiane są nowe wartości dla keyOne i keyTwo z modify-lock, a następnie wykonywana jest operacja modify-multiple-keys z workletu:

// modify-multiple-keys.js
sharedStorage.batchUpdate([
    new SharedStorageSetMethod('keyOne', calculateValueFor('keyOne')),
    new SharedStorageSetMethod('keyTwo', calculateValueFor('keyTwo'))
], { withLock: 'modify-lock' });

const modifyWorklet = await sharedStorage.createWorklet('modify-multiple-keys-worklet.js');
await modifyWorklet.run('modify-multiple-keys');

Następnie w modify-multiple-keys-worklet.js możesz poprosić o blokadę za pomocą navigator.locks.request(), aby odczytać i zmodyfikować klucze w razie potrzeby.

// modify-multiple-keys-worklet.js
class ModifyMultipleKeysOperation {
  async run(data) {
    await navigator.locks.request('modify-lock', async (lock) => {
      const value1 = await sharedStorage.get('keyOne');
      const value2 = await sharedStorage.get('keyTwo');

      // Do something with `value1` and `value2` here.

      await sharedStorage.delete('keyOne');
      await sharedStorage.delete('keyTwo');
    });
  }
}
register('modify-multiple-keys', ModifyMultipleKeysOperation);

Przełączanie kontekstu

Dane Shared Storage są zapisywane w źródle (np. https://example.adtech.com) kontekstu przeglądania, z którego pochodzi wywołanie.

Gdy wczytujesz kod innej firmy za pomocą tagu <script>, jest on wykonywany w kontekście przeglądania osadzającego. Dlatego, gdy kod innej firmy wywołuje sharedStorage.set(), dane są zapisywane w pamięci współdzielonej osadzającego. Gdy kod firmy zewnętrznej jest wczytywany w ramce iframe, otrzymuje on nowy kontekst przeglądania, a jego źródłem jest źródło ramki iframe. Dlatego wywołanie sharedStorage.set() z elementu iframe zapisuje dane w pamięci współdzielonej pochodzenia elementu iframe.

Kontekst własny

Jeśli na stronie własnej jest osadzony kod JavaScript innej firmy, który wywołuje funkcję sharedStorage.set() lub sharedStorage.delete(), para klucz-wartość jest przechowywana w kontekście strony własnej.

Kontekst zewnętrzny

Parę klucz-wartość można przechowywać w kontekście technologii reklamowej lub firmy zewnętrznej, tworząc element iframe i wywołując w kodzie JavaScript w ramach tego elementu funkcję set() lub delete().

Interfejs Private Aggregation API

Aby mierzyć dane podlegające agregacji przechowywane w Shared Storage, możesz używać interfejsu Private Aggregation API.

Aby utworzyć raport, wywołaj funkcję contributeToHistogram() w worklecie z zasobnikiem i wartością. Kosz jest reprezentowany przez 128-bitową liczbę całkowitą bez znaku, która musi być przekazywana do funkcji jako BigInt. Wartość jest dodatnią liczbą całkowitą.

Aby chronić prywatność, ładunek raportu zawierający przedział i wartość jest szyfrowany podczas przesyłania i może być odszyfrowany oraz agregowany tylko za pomocą usługi agregacji.

Przeglądarka ograniczy też wkład, jaki witryna może wnieść do zapytania wyjściowego. W szczególności budżet udziału ogranicza łączną liczbę wszystkich raportów z jednej witryny w przypadku danej przeglądarki w danym przedziale czasu we wszystkich segmentach. Jeśli bieżący budżet zostanie przekroczony, raport nie zostanie wygenerowany.

privateAggregation.contributeToHistogram({
  bucket: BigInt(myBucket),
  value: parseInt(myBucketValue)
});

Wykonywanie Shared Storage i Private Aggregation

Domyślnie podczas korzystania z pamięci współdzielonej z createWorklet() źródłem partycji danych będzie pochodzenie kontekstu przeglądania, a nie pochodzenie samego skryptu workletu.

Aby zmienić domyślne działanie, ustaw właściwość dataOrigin podczas wywoływania createWorklet.

• dataOrigin: "context-origin": (Domyślnie) dane są przechowywane we współdzielonym miejscu na dane pochodzącym z kontekstu przeglądania, który wywołał funkcję.
• dataOrigin: "script-origin": dane są przechowywane w pamięci współdzielonej pochodzenia skryptu workletu. Aby włączyć ten tryb, musisz wyrazić na niego zgodę.
• dataOrigin: "https://custom-data-origin.example": dane są przechowywane w pamięci współdzielonej niestandardowego źródła danych. Aby włączyć ten tryb, musisz wyrazić zgodę. Wymagana jest też zgoda właściciela niestandardowego źródła danych, jak opisano w sekcji Niestandardowe źródło danych.

sharedStorage.createWorklet(scriptUrl, {dataOrigin: "script-origin"});

Aby wyrazić zgodę, w przypadku korzystania z "script-origin" lub niestandardowego źródła punkt końcowy skryptu musi odpowiadać nagłówkiem Shared-Storage-Cross-Origin-Worklet-Allowed. W przypadku żądań z innej domeny należy też włączyć CORS.

Shared-Storage-Cross-Origin-Worklet-Allowed : ?1
Access-Control-Allow-Origin: *

Możesz też uruchamiać skrypty z różnych domen za pomocą ramki iframe innej firmy. W takim przypadku działania w pamięci współdzielonej będą wykonywane w kontekście przeglądania innej firmy.

Korzystanie z elementu iframe z innej domeny

Do wywołania workletu Shared Storage potrzebny jest element iframe.

W elemencie iframe reklamy wczytaj moduł worklet, wywołując funkcję addModule(). Aby uruchomić metodę zarejestrowaną w sharedStorageWorklet.jspliku worklet, w tym samym kodzie JavaScript elementu iframe reklamy wywołaj sharedStorage.run().

const sharedStorageWorklet = await window.sharedStorage.createWorklet(
  'https://any-origin.example/modules/sharedStorageWorklet.js'
);
await sharedStorageWorklet.run('shared-storage-report', {
  data: { campaignId: '1234' },
});

W skrypcie workletu musisz utworzyć klasę z asynchroniczną metodą run i register ją, aby działała w ramce iframe reklamy. Wewnątrz:sharedStorageWorklet.js

class SharedStorageReportOperation {
  async run(data) {
    // Other code goes here.
    bucket = getBucket(...);
    value = getValue(...);
    privateAggregation.contributeToHistogram({
      bucket,
      value
    });
  }
}
register('shared-storage-report', SharedStorageReportOperation);

Korzystanie z żądania z innej domeny

Pamięć współdzielona i prywatna agregacja umożliwiają tworzenie elementów roboczych z różnych domen bez konieczności używania elementów iframe z różnych domen.

Strona własna może też wywołać wywołanie createWorklet() do punktu końcowego JavaScript z innej domeny. Podczas tworzenia elementu roboczego musisz ustawić pochodzenie partycji danych elementu roboczego na pochodzenie skryptu.

async function crossOriginCall() {
  const privateAggregationWorklet = await sharedStorage.createWorklet(
    'https://cross-origin.example/js/worklet.js',
    { dataOrigin: 'script-origin' }
  );
  await privateAggregationWorklet.run('pa-worklet');
}
crossOriginCall();

Punkt końcowy JavaScript z innej domeny będzie musiał odpowiedzieć nagłówkami Shared-Storage-Cross-Origin-Worklet-Allowed i zwrócić uwagę, że dla żądania włączono CORS.

Shared-Storage-Cross-Origin-Worklet-Allowed : ?1

Worklety utworzone za pomocą createWorklet() będą miały selectURL i run(). addModule() nie jest dostępna w tym przypadku.

class CrossOriginWorklet {
  async run(data){
    // Other code goes here.
    bucket = getBucket(...);
    value = getValue(...);
    privateAggregation.contributeToHistogram({
      bucket,
      value
    });
  }
}

Niestandardowe źródło danych

Gdy parametr dataOrigin jest ustawiony na prawidłową domenę, właściciel dataOrigin musi wyrazić zgodę na przetwarzanie pamięci współdzielonej na potrzeby tej domeny dataOrigin, hostując plik JSON z listą domen skryptu worklet w ścieżce /.well-known/shared-storage/trusted-origins. Plik powinien być tablicą obiektów z kluczami scriptOrigin i contextOrigin. Wartości tych kluczy mogą być ciągami tekstowymi lub tablicami ciągów tekstowych.

Utwórz plik trusted-origins, korzystając z tych informacji:

• Kontekst rozmówcy
• Pochodzenie i adres URL skryptu workletu
• Źródło danych i właściciel

W tabeli poniżej pokazujemy, jak na podstawie tych informacji można utworzyć plik trusted-origins:

[{
  "scriptOrigin": "https://cdn-ad.example",
  "contextOrigin": "https://publisher.example"
}]
      

[{
  "scriptOrigin": "https://cdn-ad.example",
  "contextOrigin": "*"
}]
      

[{
  "scriptOrigin": "https://cdn-ad.example",
  "contextOrigin": [
      "https://publisher-a.example",
      "https://publisher-b.example"
  ]
}]
      

[{
  "scriptOrigin": [
    "https://cdn-a-ad.example",
    "https://cdn-b-ad.example"
  ],
  "contextOrigin": "https://publisher.example"
}]
      

Na przykład poniższy kod JSON może być hostowany pod adresem https://custom-data-origin.example/.well-known/shared-storage/trusted-origins i łączyć wszystkich dozwolonych procesorów danych z pamięci współdzielonej dla pochodzenia https://custom-data-origin.example.

[
  {
    "scriptOrigin": "https://script-origin.a.example",
    "contextOrigin": "https://context-origin.a.example"
  },
  {
    "scriptOrigin": "https://script-origin.b.example",
    "contextOrigin": [
      "https://context-origin.a.example",
      "https://context-origin.b.example"
    ]
}]

Dalsze kroki

Na kolejnych stronach znajdziesz ważne informacje o interfejsach Shared Storage i Private Aggregation API.

• Wprowadzenie do Shared Storage (Chrome dla deweloperów)
• Przypadki użycia Shared Storage (Chrome dla deweloperów)
• Wprowadzenie do prywatnej agregacji (Chrome dla deweloperów)
• Wyjaśnienie dotyczące Shared Storage (GitHub)
• Wyjaśnienie dotyczące prywatnej agregacji (GitHub)
• Prezentacja interfejsów Shared Storage i Private Aggregation

Gdy zapoznasz się z interfejsami API, możesz zacząć zbierać raporty, które są wysyłane jako żądanie POST do tych punktów końcowych w formacie JSON w treści żądania.

• Raporty debugowania – context-origin/.well-known/private-aggregation/debug/report-shared-storage
• Raporty – context-origin/.well-known/private-aggregation/report-shared-storage

Po zebraniu raportów możesz je przetestować za pomocą narzędzia do testowania lokalnego lub skonfigurować zaufane środowisko wykonawcze dla usługi do agregacji, aby uzyskać raporty zbiorcze.

Prześlij opinię

Swoją opinię na temat interfejsów API i dokumentacji możesz przesłać na GitHubie.

• Shared Storage
• Agregacja prywatna