Authentifizierung für das Braze SDK 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. Dies betrifft:

• Senden von angepassten Events, Attributen, Käufen und Sitzungsdaten
• Erstellen neuer Nutzer:innen in Ihrem Braze-Workspace
• Aktualisieren von Standardattributen des Nutzerprofils
• Empfangen oder Triggern von Nachrichten

So können Sie verhindern, dass nicht authentifizierte angemeldete Nutzer:innen den SDK-API-Schlüssel Ihrer App verwenden, um böswillige Aktionen durchzuführen, wie z. B. das Imitieren anderer Nutzer:innen.

Authentifizierung einrichten

Schritt 1: Server einrichten

Schritt 1.1: Öffentliches/privates Schlüsselpaar generieren

Generieren Sie ein RSA256-Public/Private-Key-Paar. Der Public Key wird später im Braze-Dashboard hinzugefügt, während der Private Key sicher auf Ihrem Server gespeichert werden sollte.

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

Warnung

Denken Sie daran, Ihre Private Keys privat zu halten. Geben Sie Ihren Private Key niemals preis und codieren Sie ihn niemals fest in Ihrer App oder Website. Jede Person, die Ihren Private Key kennt, kann Nutzer:innen in Ihrem Namen imitieren oder erstellen.

Schritt 1.2: JSON Web Token für die aktuelle Nutzerin oder den aktuellen Nutzer erstellen

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

Typischerweise könnte diese Logik dort implementiert werden, wo Ihre App normalerweise das Profil der aktuellen Nutzerin oder des aktuellen Nutzers abfragt – zum Beispiel an einem Login-Endpunkt oder überall dort, wo Ihre App das aktuelle Kundenprofil aktualisiert.

Bei der Generierung 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.

Schritt 2: SDK konfigurieren

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

Hinweis

Für iOS-Integrationen beschreibt diese Seite die Schritte für das Braze Swift SDK. Für die Beispielverwendung im Legacy-AppboyKit-iOS-SDK beziehen Sie sich auf diese Datei und diese Datei.

Schritt 2.1: Authentifizierung im Braze SDK aktivieren

Wenn dieses Feature aktiviert ist, hängt das Braze SDK das zuletzt bekannte JWT der aktuellen Nutzerin oder des aktuellen Nutzers an Netzwerkanfragen an Braze-Server an.

Hinweis

Keine Sorge – die alleinige Initialisierung mit dieser Option hat keinerlei Auswirkungen auf die Datenerfassung, bis Sie die Authentifizierung erzwingen im Braze-Dashboard.

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

Setzen Sie beim Aufruf von initialize 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 nativen SDK-Initialisierung 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>

Nach der Aktivierung der SDK-Authentifizierung in der nativen Schicht können Sie die in den folgenden Schritten gezeigten React-Native-JavaScript-Methoden verwenden.

Rufen Sie beim Konfigurieren der Braze-Instanz setIsSdkAuthenticationEnabled mit dem Wert true auf.

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

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

Rufen Sie beim Konfigurieren der Braze-Instanz setIsSdkAuthenticationEnabled mit dem Wert true auf.

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

Alternativ können Sie <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 als Teil der SDK-Initialisierung 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 aus 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 SDK-Initialisierung im nativen iOS- und Android-Code aktiviert werden. Wenn sie in der nativen Schicht aktiviert ist, können Sie 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>

Nach der Aktivierung der SDK-Authentifizierung in der nativen Schicht können Sie die in den folgenden Schritten gezeigten Flutter-SDK-Methoden verwenden.

Die SDK-Authentifizierung muss während der nativen SDK-Initialisierung 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>

Nach der Aktivierung der SDK-Authentifizierung in der nativen Schicht können Sie die in den folgenden Schritten gezeigten Unity-C#-Methoden verwenden.

Die SDK-Authentifizierung muss während der nativen SDK-Initialisierung 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>

Nach der Aktivierung der SDK-Authentifizierung in der nativen Schicht können Sie die in den folgenden Schritten gezeigten Cordova-JavaScript-Methoden verwenden.

Die SDK-Authentifizierung muss während der nativen SDK-Initialisierung 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 auf true, wenn Sie das SDK initialisieren:

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 gezeigten .NET-MAUI-Methoden verwenden.

Wenn Sie das Braze Expo Plugin verwenden, setzen Sie die Eigenschaft enableSdkAuthentication in Ihrer App-Konfiguration auf true. Dies konfiguriert die SDK-Authentifizierung automatisch in den nativen iOS- und Android-Schichten, ohne dass manuelle native Code-Änderungen 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
        }
      ]
    ]
  }
}

Nach der Aktivierung der SDK-Authentifizierung in Ihrer App-Konfiguration können Sie die im React-Native-Tab gezeigten 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: JWT der aktuellen Nutzerin oder des aktuellen Nutzers setzen

Immer wenn Ihre App die Braze-Methode changeUser aufruft, übergeben Sie auch das JWT, das serverseitig generiert wurde.

Sie können das Token auch so konfigurieren, dass es während der Sitzung für die aktuelle Nutzerin oder den aktuellen Nutzer aktualisiert wird.

Hinweis

Beachten Sie, dass changeUser nur aufgerufen werden sollte, wenn sich die Nutzer-ID tatsächlich geändert hat. Sie sollten diese Methode nicht verwenden, um das Authentifizierungstoken (JWT) zu aktualisieren, wenn sich die Nutzer-ID nicht geändert hat.

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

Übergeben Sie das JWT beim Aufruf von changeUser:

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

Übergeben Sie das JWT beim Aufruf von changeUser:

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

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

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

Übergeben Sie das JWT beim Aufruf von changeUser:

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

Übergeben Sie das JWT beim Aufruf von changeUser:

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

Übergeben Sie das JWT beim Aufruf von changeUser:

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

Übergeben Sie das JWT beim Aufruf von changeUser:

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

Hinweis

changeUser gibt sofort auf dem aufrufenden Thread zurück. Die hier übergebene SDK-Authentifizierungssignatur wird angehängt, nachdem der Nutzerwechsel abgeschlossen ist.

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

Übergeben Sie das JWT beim Aufruf von changeUser:

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

Übergeben Sie das JWT beim Aufruf von changeUser:

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

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

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

Übergeben Sie das JWT beim Aufruf von ChangeUser:

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

Übergeben Sie das JWT beim Aufruf von changeUser:

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

Übergeben Sie das JWT beim Aufruf von ChangeUser:

iOS

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

Android

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

Wenn Sie das Braze Expo Plugin verwenden, nutzen Sie die gleichen React-Native-SDK-Methoden. Übergeben Sie das JWT beim Aufruf von changeUser:

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

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

Oder wenn Sie das Token der Nutzerin oder des Nutzers während der Sitzung aktualisiert haben:

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

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

Schritt 2.3: Callback-Funktion für ungültige Token manuell registrieren

Wenn dieses Feature auf Erforderlich gesetzt ist, führen die folgenden Szenarien dazu, dass SDK-Anfragen von Braze abgelehnt werden:

• Das JWT war zum Zeitpunkt des Eingangs bei der Braze-API abgelaufen
• Das JWT war leer oder fehlte
• Die JWT-Verifizierung ist für die Public Keys, die Sie im Braze-Dashboard hochgeladen haben, fehlgeschlagen

Sie können subscribeToSdkAuthenticationFailures verwenden, um benachrichtigt zu werden, 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 Nutzerin oder der Nutzer darf nicht anonym sein) und dem Authentifizierungstoken (JWT), das den Fehler verursacht hat.

Fehlgeschlagene Anfragen werden periodisch wiederholt, bis Ihre App ein neues gültiges JWT bereitstellt. Wenn diese Nutzerin oder dieser Nutzer noch angemeldet ist, können Sie diesen Callback als Gelegenheit nutzen, 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 Nutzerin oder dem aktuell angemeldeten Nutzer übereinstimmt. Rufen Sie dann eine neue Signatur von Ihrem Server ab und übergeben Sie sie dem Braze SDK. Sie können diese Fehler auch in Ihrem Monitoring- oder Fehlerberichtsdienst protokollieren.

Tipp

Diese Callback-Methoden sind ein hervorragender Ort, um Ihren eigenen Monitoring- oder Fehlerprotokollierungsdienst hinzuzufügen, um zu verfolgen, wie oft Ihre Braze-Anfragen abgelehnt werden.

• internet
• 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();

Schritt 3: Authentifizierung im Dashboard aktivieren

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

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

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

Erzwingungsoptionen

Auf der Seite Einstellungen verwalten im Dashboard hat jede App drei SDK-Authentifizierungszustände, die steuern, wie Braze Anfragen verifiziert.

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

Ein ungültiges JWT wird sowohl im Zustand Optional als auch im Zustand Erforderlich gemeldet. Jedoch lehnt nur der Zustand Erforderlich SDK-Anfragen ab, was dazu führt, dass Apps den Vorgang wiederholen und ein neues JWT anfordern.

Ö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 Upgrade 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.