SDK-Authentifizierung einrichten

Mit der SDK-Authentifizierung können Sie SDK-Anfragen, die im Namen von angemeldeten Nutzer:innen gestellt werden, einen (serverseitig generierten) kryptografischen Beweis liefern.

Funktionsweise

Nachdem Sie dieses Feature in Ihrer App aktiviert haben, können Sie das Braze-Dashboard so konfigurieren, dass alle Anfragen mit einem ungültigen oder fehlenden JSON Web Token (JWT) abgelehnt werden. Dazu gehören:

• Versenden von angepassten Events, Attributen, Käufen und Sitzungsdaten
• Erstellen neuer Nutzer:innen in Ihrem Braze Workspace
• Aktualisieren von Standard-Nutzerprofil-Attributen
• Empfangen oder Triggern von Nachrichten

So können Sie verhindern, dass nicht authentifizierte angemeldete Nutzer:innen den SDK-API-Schlüssel Ihrer App für unzulässige Handlungen verwenden, beispielsweise um sich als andere Nutzer:innen auszugeben.

Authentifizierung einrichten

1. Schritt: Richten Sie Ihren Server ein

Schritt 1.1: Erzeugen eines Public/Private-Key-Paars

Erzeugen Sie ein RSA256 Public/Private-Key-Paar. Der Public Key wird schließlich dem Braze-Dashboard hinzugefügt, während der Private Key sicher auf Ihrem Server gespeichert werden muss.

Wir empfehlen einen RSA-Schlüssel mit 2048 Bit für die Verwendung mit dem RS256 JWT-Algorithmus.

Warnung

Denken Sie daran, Ihre Private Keys immer geheim zu halten. Geben Sie Ihren Private Key niemals in Ihrer App oder auf Ihrer Website preis und codieren Sie ihn nicht fest ein. Jeder, der Ihren Private Key kennt, kann sich als Nutzer:innen ausgeben oder Nutzer:innen im Namen Ihrer Anwendung erstellen.

Schritt 1.2: Erstellen Sie ein JSON Web Token für die aktuelle Nutzer:in

Sobald Sie Ihren Private Key haben, sollte Ihre serverseitige Anwendung ihn verwenden, um ein JWT für die aktuell angemeldete Nutzer:in an Ihre App oder Website zurückzugeben.

Typischerweise könnte diese Logik überall dort zum Einsatz kommen, wo Ihre App normalerweise das Profil der aktuellen Nutzer:in anfragen würde, z. B. an einem Endpunkt für die Anmeldung oder wo Ihre App das Profil der aktuellen Nutzer:in aktualisiert.

Bei der Erstellung des JWT werden die folgenden Felder erwartet:

JWT-Header

JWT-Payload

Tipp

Um mehr über JSON Web Tokens zu erfahren oder die vielen Open-Source-Bibliotheken zu durchsuchen, die diesen Signierungsprozess vereinfachen, besuchen Sie https://jwt.io.

2. Schritt: SDK konfigurieren

Dieses Feature ist ab den folgenden SDK-Versionen verfügbar:

Hinweis

Für iOS-Integrationen finden Sie auf dieser Seite die Schritte für das Braze Swift SDK. Für Beispiele zur Verwendung im Legacy-AppboyKit-iOS-SDK referenzieren Sie diese Datei und diese Datei.

Schritt 2.1: Aktivieren Sie die Authentifizierung im Braze SDK.

Wenn dieses Feature aktiviert ist, fügt das Braze SDK das letzte bekannte JWT der aktuellen Nutzer:in an Netzwerkanfragen an Braze Server an.

Hinweis

Keine Sorge, die Initialisierung mit dieser Option allein hat keinerlei Auswirkungen auf die Datenerfassung, solange Sie nicht im Braze-Dashboard die Authentifizierung erzwingen.

• web
• react native
• java
• kotlin
• objective-c
• swift
• dart
• flutter
• unity
• cordova
• .net maui (xamarin)
• expo

Wenn Sie initialize aufrufen, setzen Sie die optionale Eigenschaft enableSdkAuthentication auf true.

1
2
3
4
5
import * as braze from "@braze/web-sdk";
braze.initialize("YOUR-API-KEY-HERE", {
  baseUrl: "YOUR-SDK-ENDPOINT-HERE",
  enableSdkAuthentication: true,
});

Die SDK-Authentifizierung muss während der Initialisierung des nativen SDK aktiviert werden. Fügen Sie die folgende Konfiguration zu Ihrem nativen iOS- und Android-Code hinzu:

iOS (AppDelegate.swift)

1
2
3
4
5
6
7
8
9
10
11
12
import BrazeKit
import braze_react_native_sdk

let configuration = Braze.Configuration(
  apiKey: "{YOUR-BRAZE-API-KEY}",
  endpoint: "{YOUR-BRAZE-ENDPOINT}"
)
configuration.api.sdkAuthentication = true
let braze = BrazeReactBridge.perform(
  #selector(BrazeReactBridge.initBraze(_:)),
  with: configuration
).takeUnretainedValue() as! Braze

Android (braze.xml)

1
<bool name="com_braze_sdk_authentication_enabled">true</bool>

Nachdem Sie die SDK-Authentifizierung in der nativen Ebene aktiviert haben, können Sie die in den folgenden Schritten aufgeführten React Native JavaScript-Methoden verwenden.

Wenn Sie die Braze-Instanz konfigurieren, rufen Sie setIsSdkAuthenticationEnabled mit true auf.

1
2
3
BrazeConfig.Builder brazeConfigBuilder = new BrazeConfig.Builder()
    .setIsSdkAuthenticationEnabled(true);
Braze.configure(this, brazeConfigBuilder.build());

Alternativ können Sie auch <bool name="com_braze_sdk_authentication_enabled">true</bool> zu Ihrer braze.xml hinzufügen.

Wenn Sie die Braze-Instanz konfigurieren, rufen Sie setIsSdkAuthenticationEnabled mit true auf.

1
2
3
BrazeConfig.Builder brazeConfigBuilder = BrazeConfig.Builder()
    .setIsSdkAuthenticationEnabled(true)
Braze.configure(this, brazeConfigBuilder.build())

Alternativ können Sie auch <bool name="com_braze_sdk_authentication_enabled">true</bool> zu Ihrer braze.xml hinzufügen.

Um die SDK-Authentifizierung zu aktivieren, setzen Sie die Eigenschaft configuration.api.sdkAuthentication Ihres BRZConfiguration-Objekts auf YES, bevor Sie die Braze-Instanz initialisieren:

1
2
3
4
5
6
BRZConfiguration *configuration =
    [[BRZConfiguration alloc] initWithApiKey:@"{BRAZE_API_KEY}"
                                    endpoint:@"{BRAZE_ENDPOINT}"];
configuration.api.sdkAuthentication = YES;
Braze *braze = [[Braze alloc] initWithConfiguration:configuration];
AppDelegate.braze = braze;

Um die SDK-Authentifizierung zu aktivieren, setzen Sie die Eigenschaft configuration.api.sdkAuthentication Ihres Braze.Configuration-Objekts auf true, wenn Sie das SDK initialisieren:

1
2
3
4
5
let configuration = Braze.Configuration(apiKey: "{YOUR-BRAZE-API-KEY}",
                                        endpoint: "{YOUR-BRAZE-ENDPOINT}")
configuration.api.sdkAuthentication = true
let braze = Braze(configuration: configuration)
AppDelegate.braze = braze

Derzeit muss die SDK-Authentifizierung im Rahmen der Initialisierung des SDK im nativen iOS- und Android-Code aktiviert werden. Um die SDK-Authentifizierung im Flutter SDK zu aktivieren, folgen Sie den Integrationen für iOS und Android auf den anderen Tabs. Nachdem die SDK-Authentifizierung aktiviert ist, kann der Rest des Features in Dart integriert werden.

Die SDK-Authentifizierung muss als Teil der Initialisierung des SDK im nativen iOS- und Android-Code aktiviert werden. Wenn sie in der nativen Ebene aktiviert ist, können Sie die Flutter-SDK-Methoden verwenden, um die JWT-Signatur zu übergeben.

iOS

Um die SDK-Authentifizierung zu aktivieren, setzen Sie die Eigenschaft configuration.api.sdkAuthentication in Ihrem nativen iOS-Code auf true:

1
2
3
let configuration = Braze.Configuration(apiKey: "{YOUR-BRAZE-API-KEY}", endpoint: "{YOUR-BRAZE-ENDPOINT}")
configuration.api.sdkAuthentication = true
let braze = Braze(configuration: configuration)

Android (braze.xml)

1
<bool name="com_braze_sdk_authentication_enabled">true</bool>

Nachdem Sie die SDK-Authentifizierung in der nativen Ebene aktiviert haben, können Sie die in den folgenden Schritten aufgeführten Flutter-SDK-Methoden verwenden.

Die SDK-Authentifizierung muss während der Initialisierung des nativen SDK aktiviert werden. Fügen Sie die folgende Konfiguration zu Ihrem nativen iOS- und Android-Code hinzu:

iOS

Setzen Sie die Eigenschaft SDKAuthenticationEnabled in Ihrer Konfigurationsdatei auf true:

1
2
<key>SDKAuthenticationEnabled</key>
<true/>

Android (braze.xml)

1
<bool name="com_braze_sdk_authentication_enabled">true</bool>

Nachdem Sie die SDK-Authentifizierung in der nativen Ebene aktiviert haben, können Sie die in den folgenden Schritten aufgeführten Unity-C#-Methoden verwenden.

Die SDK-Authentifizierung muss während der Initialisierung des nativen SDK aktiviert werden. Fügen Sie die folgende Konfiguration zu Ihrem nativen iOS- und Android-Code hinzu:

iOS

Um die SDK-Authentifizierung zu aktivieren, setzen Sie die Eigenschaft enableSDKAuthentication in Ihrer config.xml auf true:

1
<preference name="com.braze.ios_enable_sdk_authentication" value="true" />

Android (braze.xml)

1
<bool name="com_braze_sdk_authentication_enabled">true</bool>

Nachdem Sie die SDK-Authentifizierung in der nativen Ebene aktiviert haben, können Sie die in den folgenden Schritten aufgeführten Cordova-JavaScript-Methoden verwenden.

Die SDK-Authentifizierung muss während der Initialisierung des nativen SDK aktiviert werden. Konfigurieren Sie die SDK-Authentifizierung separat für iOS und Android:

iOS

Um die SDK-Authentifizierung zu aktivieren, setzen Sie die Eigenschaft configuration.Api.SdkAuthentication bei der Initialisierung des SDK auf true:

1
2
3
var configuration = new BRZConfiguration("YOUR-API-KEY", "YOUR-ENDPOINT");
configuration.Api.SdkAuthentication = true;
var braze = new Braze(configuration);

Android (braze.xml)

1
<bool name="com_braze_sdk_authentication_enabled">true</bool>

Nach der Aktivierung der SDK-Authentifizierung können Sie die in den folgenden Schritten aufgeführten .NET MAUI-Methoden verwenden.

Bei Verwendung des Braze Expo-Plugins setzen Sie die Eigenschaft enableSdkAuthentication in Ihrer App-Konfiguration auf true. Dadurch wird die SDK-Authentifizierung automatisch in den nativen iOS- und Android-Schichten konfiguriert, ohne dass manuelle Änderungen am nativen Code erforderlich sind.

app.json oder app.config.js

1
2
3
4
5
6
7
8
9
10
11
12
{
  "expo": {
    "plugins": [
      [
        "@braze/expo-plugin",
        {
          "enableSdkAuthentication": true
        }
      ]
    ]
  }
}

Nachdem Sie die SDK-Authentifizierung in Ihrer App-Konfiguration aktiviert haben, können Sie die auf dem React-Native-Tab angezeigten React Native JavaScript-Methoden für die folgenden Schritte verwenden.

Hinweis

Ein vollständiges Implementierungsbeispiel finden Sie in der Braze Expo-Plugin-Beispiel-App auf GitHub.

Schritt 2.2: Setzen Sie das JWT der aktuellen Nutzer:in

Wann immer Ihre App die Braze-Methode changeUser aufruft, geben Sie auch das JWT an, das serverseitig generiert wurde.

Sie können das Token auch so konfigurieren, dass es mitten in der Sitzung für die aktuelle Nutzer:in aktualisiert wird.

Hinweis

Denken Sie daran, dass changeUser nur aufgerufen werden sollte, wenn die Nutzer-ID sich tatsächlich geändert hat. Sie sollten diese Methode nicht zum Aktualisieren des Authentifizierungs-Tokens (JWT) verwenden, wenn sich die Nutzer-ID nicht geändert hat.

• web
• react native
• java
• kotlin
• objective-c
• swift
• dart
• flutter
• unity
• cordova
• .net maui (xamarin)
• expo

1
2
import * as braze from "@braze/web-sdk";
braze.changeUser("NEW-USER-ID", "JWT-FROM-SERVER");

1
2
import * as braze from "@braze/web-sdk";
braze.setSdkAuthenticationSignature("NEW-JWT-FROM-SERVER");

1
2
3
import Braze from '@braze/react-native-sdk';

Braze.changeUser("NEW-USER-ID", "JWT-FROM-SERVER");

1
2
3
import Braze from '@braze/react-native-sdk';

Braze.setSdkAuthenticationSignature("NEW-JWT-FROM-SERVER");

1
Braze.getInstance(this).changeUser("NEW-USER-ID", "JWT-FROM-SERVER");

1
Braze.getInstance(this).setSdkAuthenticationSignature("NEW-JWT-FROM-SERVER");

1
Braze.getInstance(this).changeUser("NEW-USER-ID", "JWT-FROM-SERVER")

1
Braze.getInstance(this).setSdkAuthenticationSignature("NEW-JWT-FROM-SERVER")

1
[AppDelegate.braze changeUser:@"userId" sdkAuthSignature:@"JWT-FROM-SERVER"];

1
[AppDelegate.braze setSDKAuthenticationSignature:@"NEW-JWT-FROM-SERVER"];

1
AppDelegate.braze?.changeUser(userId: "userId", sdkAuthSignature: "JWT-FROM-SERVER")

1
AppDelegate.braze?.set(sdkAuthenticationSignature: "NEW-JWT-FROM-SERVER")

1
braze.changeUser("userId", sdkAuthSignature: "JWT-FROM-SERVER")

1
braze.setSdkAuthenticationSignature("NEW-JWT-FROM-SERVER")

1
2
3
4
import 'package:braze_plugin/braze_plugin.dart';

BrazePlugin braze = BrazePlugin();
braze.changeUser("NEW-USER-ID", sdkAuthSignature: "JWT-FROM-SERVER");

1
2
3
4
import 'package:braze_plugin/braze_plugin.dart';

BrazePlugin braze = BrazePlugin();
braze.setSdkAuthenticationSignature("NEW-JWT-FROM-SERVER");

1
BrazeBinding.ChangeUser("NEW-USER-ID", "JWT-FROM-SERVER");

1
BrazeBinding.SetSdkAuthenticationSignature("NEW-JWT-FROM-SERVER");

1
BrazePlugin.changeUser("NEW-USER-ID", "JWT-FROM-SERVER");

1
BrazePlugin.setSdkAuthenticationSignature("NEW-JWT-FROM-SERVER");

1
Braze.SharedInstance?.ChangeUser("NEW-USER-ID", "JWT-FROM-SERVER");

1
Braze.SharedInstance?.SetSDKAuthenticationSignature("NEW-JWT-FROM-SERVER");

1
Braze.GetInstance(this).ChangeUser("NEW-USER-ID", "JWT-FROM-SERVER");

1
Braze.GetInstance(this).SetSdkAuthenticationSignature("NEW-JWT-FROM-SERVER");

1
2
3
import Braze from '@braze/react-native-sdk';

Braze.changeUser("NEW-USER-ID", "JWT-FROM-SERVER");

1
2
3
import Braze from '@braze/react-native-sdk';

Braze.setSdkAuthenticationSignature("NEW-JWT-FROM-SERVER");

Schritt 2.3: Registrieren Sie eine Callback-Funktion für ungültige Token

Wenn dieses Feature auf Erforderlich gesetzt ist, werden SDK-Anfragen in den folgenden Fällen von Braze abgelehnt:

• Das JWT war zum Zeitpunkt des Empfangs durch die Braze API bereits abgelaufen
• Das JWT war leer oder fehlte
• Das JWT konnte für die Public Keys, die Sie in das Braze-Dashboard hochgeladen haben, nicht verifiziert werden

Mit subscribeToSdkAuthenticationFailures können Sie sich benachrichtigen lassen, wenn SDK-Anfragen aus einem dieser Gründe fehlschlagen. Eine Callback-Funktion enthält ein Objekt mit dem relevanten errorCode, dem reason für den Fehler, der userId der Anfrage (die Nutzer:in kann nicht anonym sein) und dem Authentifizierungstoken (JWT), das den Fehler verursacht hat.

Fehlgeschlagene Anfragen werden regelmäßig wiederholt, bis Ihre App ein neues gültiges JWT liefert. Wenn die Nutzer:in noch angemeldet ist, können Sie diesen Callback nutzen, um ein neues JWT von Ihrem Server anzufordern und das Braze SDK mit diesem neuen gültigen Token zu versorgen.

Wenn Sie einen Authentifizierungsfehler erhalten, überprüfen Sie, ob die userId im Fehler mit der aktuell angemeldeten Nutzer:in übereinstimmt. Fordern Sie anschließend eine neue Signatur von Ihrem Server an und übermitteln Sie diese an das Braze SDK. Sie können diese Fehler auch in Ihrem Überwachungs- oder Fehlerberichtsdienst protokollieren.

Tipp

Diese Callback-Methoden eignen sich hervorragend, um Ihren eigenen Überwachungs- oder Fehlerprotokollierungsdienst hinzuzufügen, damit Sie verfolgen können, wie oft Ihre Braze-Anfragen abgelehnt werden.

• web
• react native
• java
• kotlin
• objective-c
• swift
• dart
• flutter
• unity
• cordova
• .net maui (xamarin)
• expo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import * as braze from "@braze/web-sdk";

braze.subscribeToSdkAuthenticationFailures((error) => {
  console.error("SDK authentication failed:", error);
  console.log("Error code:", error.errorCode);
  console.log("User ID:", error.userId);
  // Note: Do not log error.signature as it contains sensitive authentication credentials

  // Verify the error.userId matches the currently logged-in user
  // Fetch a new token from your server and set it
  fetchNewSignature(error.userId).then((newSignature) => {
    braze.setSdkAuthenticationSignature(newSignature);
  });
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import Braze from '@braze/react-native-sdk';

const sdkAuthErrorSubscription = Braze.addListener(
  Braze.Events.SDK_AUTHENTICATION_ERROR,
  (error) => {
    console.log(`SDK Authentication for ${error.userId} failed with error code ${error.errorCode}.`);

    const updated_jwt = getNewTokenSomehow(error);
    Braze.setSdkAuthenticationSignature(updated_jwt);
  }
);

// Don't forget to remove the listener when done
// sdkAuthErrorSubscription.remove();

1
2
3
4
Braze.getInstance(this).subscribeToSdkAuthenticationFailures(error -> {
    String newToken = getNewTokenSomehow(error);
    Braze.getInstance(getContext()).setSdkAuthenticationSignature(newToken);
});

1
2
3
4
Braze.getInstance(this).subscribeToSdkAuthenticationFailures({ error: BrazeSdkAuthenticationErrorEvent ->
    val newToken: String = getNewTokenSomehow(error)
    Braze.getInstance(getContext()).setSdkAuthenticationSignature(newToken)
})

1
2
3
4
5
6
7
8
9
10
Braze *braze = [[Braze alloc] initWithConfiguration:configuration];
braze.sdkAuthDelegate = delegate;
AppDelegate.braze = braze;

// Method to implement in delegate
- (void)braze:(Braze *)braze sdkAuthenticationFailedWithError:(BRZSDKAuthenticationError *)error {
  NSLog(@"Invalid SDK Authentication Token.");
  NSString *newSignature = getNewTokenSomehow(error);
  [AppDelegate.braze setSDKAuthenticationSignature:newSignature];
}

1
2
3
4
5
6
7
8
9
10
let braze = Braze(configuration: configuration)
braze.sdkAuthDelegate = delegate
AppDelegate.braze = braze

// Method to implement in delegate
func braze(_ braze: Braze, sdkAuthenticationFailedWithError error: Braze.SDKAuthenticationError) {
  print("Invalid SDK Authentication Token.")
  let newSignature = getNewTokenSomehow(error)
  AppDelegate.braze?.set(sdkAuthenticationSignature: newSignature)
}

1
2
3
4
5
braze.setBrazeSdkAuthenticationErrorCallback((BrazeSdkAuthenticationError error) async {
  print("Invalid SDK Authentication Token.");
  final newSignature = getNewTokenSomehow(error);
  braze.setSdkAuthenticationSignature(newSignature);
});

1
2
3
4
5
6
7
8
9
10
import 'package:braze_plugin/braze_plugin.dart';

BrazePlugin braze = BrazePlugin();

braze.setBrazeSdkAuthenticationErrorCallback((BrazeSdkAuthenticationError error) async {
  print("SDK Authentication for ${error.userId} failed with error code ${error.errorCode}.");

  String newSignature = getNewTokenSomehow(error);
  braze.setSdkAuthenticationSignature(newSignature);
});

1
2
3
4
5
6
7
8
9
public class SdkAuthDelegate : BRZSdkAuthDelegate
{
  public void Braze(Braze braze, BRZSDKAuthenticationError error)
  {
    Debug.Log("Invalid SDK Authentication Token.");
    string newSignature = GetNewTokenSomehow(error);
    BrazeBinding.SetSdkAuthenticationSignature(newSignature);
  }
}

1
2
3
4
Braze.GetInstance(this).SubscribeToSdkAuthenticationFailures((error) => {
  string newToken = GetNewTokenSomehow(error);
  Braze.GetInstance(this).SetSdkAuthenticationSignature(newToken);
});

1
2
3
4
5
6
BrazePlugin.subscribeToSdkAuthenticationFailures((error) => {
  console.log(`SDK Authentication for ${error.user_id} failed with error code ${error.error_code}.`);

  const newSignature = getNewTokenSomehow(error);
  BrazePlugin.setSdkAuthenticationSignature(newSignature);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class SdkAuthDelegate : BRZSdkAuthDelegate
{
  public override void Braze(Braze braze, BRZSDKAuthenticationError error)
  {
    Console.WriteLine("Invalid SDK Authentication Token.");
    string newSignature = GetNewTokenSomehow(error);
    Braze.SharedInstance?.SetSDKAuthenticationSignature(newSignature);
  }
}

// Set the delegate during initialization
var configuration = new BRZConfiguration("YOUR-API-KEY", "YOUR-ENDPOINT");
configuration.Api.SdkAuthentication = true;
var braze = new Braze(configuration);
braze.SdkAuthDelegate = new SdkAuthDelegate();

1
2
3
4
Braze.GetInstance(this).SubscribeToSdkAuthenticationFailures((error) => {
  string newToken = GetNewTokenSomehow(error);
  Braze.GetInstance(this).SetSdkAuthenticationSignature(newToken);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import Braze from '@braze/react-native-sdk';

const sdkAuthErrorSubscription = Braze.addListener(
  Braze.Events.SDK_AUTHENTICATION_ERROR,
  (error) => {
    console.log(`SDK Authentication for ${error.userId} failed with error code ${error.errorCode}.`);

    const updated_jwt = getNewTokenSomehow(error);
    Braze.setSdkAuthenticationSignature(updated_jwt);
  }
);

// Don't forget to remove the listener when done
// sdkAuthErrorSubscription.remove();

3. Schritt: Aktivieren Sie die Authentifizierung im Dashboard

Als Nächstes können Sie im Braze-Dashboard die Authentifizierung für die Apps aktivieren, die Sie zuvor eingerichtet haben.

Beachten Sie, dass SDK-Anfragen ohne Authentifizierung wie gewohnt weiterlaufen, es sei denn, die SDK-Authentifizierungseinstellung der App ist im Braze-Dashboard auf Erforderlich gesetzt.

Sollte bei Ihrer Integration etwas schiefgehen (z. B. wenn Ihre App Token fälschlicherweise an das SDK weitergibt oder Ihr Server ungültige Token generiert), deaktivieren Sie dieses Feature im Braze-Dashboard, und die Daten fließen ohne Überprüfung wie gewohnt weiter.

Durchsetzungsoptionen

Auf der Dashboard-Seite Einstellungen verwalten verfügt jede App über drei SDK-Authentifizierungsstatus, die steuern, wie Braze Anfragen überprüft.

Die Einstellung Optional ist eine nützliche Möglichkeit, die möglichen Auswirkungen dieses Features auf den SDK-Traffic Ihrer App zu überwachen.

Ein ungültiges JWT wird sowohl im Status Optional als auch im Status Erforderlich gemeldet, aber nur im Status Erforderlich werden SDK-Anfragen abgelehnt, sodass Apps es erneut versuchen und ein neues JWT anfordern müssen.

Öffentliche Schlüssel verwalten

Hinzufügen eines Public Keys

Sie können bis zu drei öffentliche Schlüssel für jede App hinzufügen: einen primären, einen sekundären und einen tertiären. Sie können denselben Schlüssel bei Bedarf auch zu mehreren Apps hinzufügen. Um einen öffentlichen Schlüssel hinzuzufügen:

1. Gehen Sie zum Braze-Dashboard und wählen Sie Settings > App Settings.
2. Wählen Sie eine App aus Ihrer Liste der verfügbaren Apps.
3. Wählen Sie unter SDK Authentication die Option Add Public Key.
4. Geben Sie eine optionale Beschreibung ein, fügen Sie Ihren Public Key ein und wählen Sie Add Public Key.

Einen neuen Primärschlüssel zuweisen

So weisen Sie einen Sekundär- oder Tertiärschlüssel als Ihren neuen Primärschlüssel zu:

1. Gehen Sie zum Braze-Dashboard und wählen Sie Settings > App Settings.
2. Wählen Sie eine App aus Ihrer Liste der verfügbaren Apps.
3. Wählen Sie unter SDK Authentication einen Schlüssel und wählen Sie Manage > Make Primary Key.

Schlüssel löschen

Um einen Primärschlüssel zu löschen, weisen Sie zunächst einen neuen Primärschlüssel zu und löschen Sie dann Ihren Schlüssel. So löschen Sie einen nicht-primären Schlüssel:

1. Gehen Sie zum Braze-Dashboard und wählen Sie Settings > App Settings.
2. Wählen Sie eine App aus Ihrer Liste der verfügbaren Apps.
3. Wählen Sie unter SDK Authentication einen nicht-primären Schlüssel und wählen Sie Manage > Delete Public Key.

Analytics

Jede App zeigt eine Aufschlüsselung der SDK-Authentifizierungsfehler, die gesammelt wurden, während sich dieses Feature im Status Optional oder Erforderlich befindet.

Die Daten sind in Realtime verfügbar, und Sie können den Mauszeiger über Datenpunkte im Chart bewegen, um eine Aufschlüsselung der Fehler für ein bestimmtes Datum zu sehen.

Fehlercodes

Häufig gestellte Fragen (FAQ)

Muss dieses Feature in allen meinen Apps gleichzeitig aktiviert werden?

Nein, dieses Feature kann für bestimmte Apps aktiviert werden und muss nicht für alle Ihre Apps auf einmal verwendet werden.

Was passiert mit Nutzer:innen, die noch ältere Versionen meiner App verwenden?

Wenn Sie damit beginnen, dieses Feature zu erzwingen, werden Anfragen von älteren App-Versionen von Braze abgelehnt und vom SDK erneut versucht. Nachdem Nutzer:innen ihre App auf eine unterstützte Version aktualisiert haben, werden diese in der Warteschlange befindlichen Anfragen wieder akzeptiert.

Wenn möglich, sollten Sie Nutzer:innen zum Upgraden auffordern, wie Sie es bei jedem anderen Pflichtupdate tun würden. Alternativ können Sie das Feature optional lassen, bis Sie sehen, dass ein akzeptabler Prozentsatz der Nutzer:innen aktualisiert hat.

Welche Gültigkeitsdauer sollte ich bei der Erstellung eines JWTs verwenden?

Wir empfehlen, den höheren Wert der durchschnittlichen Sitzungsdauer, des Ablaufs von Sitzungs-Cookies/-Tokens oder der Häufigkeit zu verwenden, mit der Ihre Anwendung sonst das Profil der aktuellen Nutzer:in aktualisieren würde.

Was passiert, wenn ein JWT mitten in der Sitzung einer Nutzer:in abläuft?

Sollte das Token einer Nutzer:in mitten in der Sitzung ablaufen, verfügt das SDK über eine Callback-Funktion, die Ihre App darüber informiert, dass ein neues JWT erforderlich ist, um weiterhin Daten an Braze zu senden.

Was passiert, wenn meine serverseitige Integration nicht mehr funktioniert und ich kein JWT mehr erstellen kann?

Wenn Ihr Server kein JWT bereitstellen kann oder Sie ein Problem bei der Integration feststellen, können Sie das Feature jederzeit im Braze-Dashboard deaktivieren.

Nach der Deaktivierung werden alle ausstehenden fehlgeschlagenen SDK-Anfragen vom SDK erneut versucht und von Braze akzeptiert.

Warum verwendet dieses Feature Public/Private Keys und nicht Shared Secrets?

Bei der Verwendung von Shared Secrets könnte jeder, der Zugriff auf dieses Shared Secret hat, z. B. über die Braze-Dashboard-Seite, Token generieren und sich als Ihre Endnutzer:innen ausgeben.

Stattdessen verwenden wir Public/Private Keys, sodass selbst Braze-Mitarbeitende (geschweige denn die Nutzer:innen Ihres Unternehmens) keinen Zugriff auf Ihre Private Keys haben.

Wie werden abgelehnte Anfragen erneut versucht?

Wenn eine Anfrage aufgrund eines Authentifizierungsfehlers abgelehnt wird, ruft das SDK Ihren Callback auf, mit dem Sie das JWT der Nutzer:in aktualisieren können.

Anfragen werden in regelmäßigen Abständen mit einem exponentiellen Backoff-Verfahren wiederholt. Nach 50 aufeinanderfolgenden Fehlversuchen werden die Wiederholungen bis zum nächsten Sitzungsstart pausiert. Jedes SDK verfügt auch über eine Methode zur manuellen Anforderung eines Data Flush.

Kann die SDK-Authentifizierung für anonyme Nutzer:innen verwendet werden?

Nein. Die SDK-Authentifizierung funktioniert, indem Ihre Website die Identität einer Person bestätigt, daher gilt sie nur für identifizierte Nutzer:innen. Als anonyme:r Nutzer:in gibt es keine Identität, die bestätigt werden könnte.

Die Durchsetzung beginnt nach dem Aufruf von changeUser. Bevor eine Nutzer:in identifiziert wird (z. B. beim anonymen Browsen vor der Registrierung), kann das SDK weiterhin Daten ohne JWT an Braze senden. Nach dem Aufruf von changeUser benötigen Anfragen für dieses identifizierte Profil ein gültiges JWT.

Das bedeutet, dass eine typische User Journey so aussehen könnte:

1. Eine Nutzer:in besucht Ihre Website oder öffnet Ihre App anonym. Braze erfasst diese Aktivität ohne JWT.
2. Die Nutzer:in registriert sich oder meldet sich an, und Ihre App ruft changeUser mit einer external_id auf.
3. Braze erfasst weiterhin die Aktivität für diese Nutzer:in, und die SDK-Authentifizierung wird für Anfragen dieses identifizierten Profils erzwungen.

Funktioniert die SDK-Authentifizierung mit Nutzer-Aliasen?

Nein. Die SDK-Authentifizierung erfordert eine external_id. Sie kann nicht eingerichtet werden, wenn nur eine braze_id oder alias_id verfügbar ist, daher können Alias-only-Profile die SDK-Authentifizierung nicht verwenden.

Blockiert die Aktivierung der SDK-Authentifizierung die Erfassung nicht authentifizierter Aktivitäten?

Nein. Die SDK-Authentifizierung blockiert keine legitime anonyme Aktivitätserfassung. Sie greift erst, nachdem ein Profil mit changeUser identifiziert wurde.