Skip to content

Configure a autenticação do SDK

A autenticação do SDK permite fornecer prova criptográfica (gerada no lado do servidor) para solicitações do SDK feitas em nome de usuários registrados.

Como funciona

Depois de ativar esse recurso no seu app, você pode configurar o dashboard da Braze para rejeitar qualquer solicitação com um JSON Web Token (JWT) inválido ou ausente, incluindo:

  • Envio de eventos personalizados, atributos, compras e dados de sessão
  • Criação de novos usuários no seu espaço de trabalho da Braze
  • Atualização de atributos padrão do perfil de usuário
  • Recebimento ou disparo de mensagens

Agora você pode impedir que usuários autenticados incorretamente utilizem a chave de API do SDK do seu app para realizar ações maliciosas, como se passar por outros usuários.

Configurando a autenticação

Etapa 1: Configure seu servidor

Etapa 1.1: Gere um par de chaves pública/privada

Gere um par de chaves pública/privada RSA256. A chave pública será adicionada ao dashboard da Braze, enquanto a chave privada deve ser armazenada com segurança no seu servidor.

Recomendamos uma chave RSA com 2048 bits para uso com o algoritmo JWT RS256.

Etapa 1.2: Crie um JSON Web Token para o usuário atual

Assim que tiver sua chave privada, sua aplicação do lado do servidor deve usá-la para retornar um JWT ao seu app ou website para o usuário atualmente conectado.

Normalmente, essa lógica poderia ficar onde seu app já solicita o perfil do usuário atual; como um endpoint de login ou onde seu app atualiza o perfil do usuário atual.

Ao gerar o JWT, os seguintes campos são esperados:

Cabeçalho do JWT

Campo Obrigatório Descrição
alg Sim O algoritmo suportado é RS256.
typ Sim O tipo deve ser igual a JWT.

Carga útil do JWT

Campo Obrigatório Descrição
sub Sim O “subject” deve ser igual ao ID do usuário que você fornece ao SDK da Braze ao chamar changeUser
exp Sim A “expiration” de quando você deseja que esse token expire, como um timestamp Unix em segundos (por exemplo, 1893456000 para 1º de janeiro de 2030).

Etapa 2: Configure o SDK

Esse recurso está disponível a partir das seguintes versões do SDK:

Etapa 2.1: Ative a autenticação no SDK da Braze.

Quando esse recurso está ativado, o SDK da Braze anexará o último JWT conhecido do usuário atual às solicitações de rede feitas aos servidores da Braze.

Ao chamar initialize, defina a propriedade opcional enableSdkAuthentication como 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,
});

A autenticação do SDK deve ser ativada durante a inicialização nativa do SDK. Adicione a seguinte configuração ao seu código nativo iOS e Android:

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>

Após ativar a autenticação do SDK na camada nativa, você pode usar os métodos JavaScript do React Native mostrados nas etapas seguintes.

Ao configurar a instância da Braze, chame setIsSdkAuthenticationEnabled como true.

1
2
3

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

Alternativamente, você pode adicionar <bool name="com_braze_sdk_authentication_enabled">true</bool> ao seu braze.xml.

Ao configurar a instância da Braze, chame setIsSdkAuthenticationEnabled como true.

1
2
3

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

Alternativamente, você pode adicionar <bool name="com_braze_sdk_authentication_enabled">true</bool> ao seu braze.xml.

Para ativar a autenticação do SDK, defina a propriedade configuration.api.sdkAuthentication do seu objeto BRZConfiguration como YES antes de inicializar a instância da Braze:

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;

Para ativar a autenticação do SDK, defina a propriedade configuration.api.sdkAuthentication do seu objeto Braze.Configuration como true ao inicializar o SDK:

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

Atualmente, a autenticação do SDK deve ser ativada como parte da inicialização do SDK no código nativo iOS e Android. Para ativar a autenticação do SDK no Flutter SDK, siga as integrações para iOS e Android nas outras guias. Depois que a autenticação do SDK estiver ativada, o restante do recurso pode ser integrado em Dart.

A autenticação do SDK deve ser ativada como parte da inicialização do SDK no código nativo iOS e Android. Quando ativada na camada nativa, você pode usar os métodos do Flutter SDK para passar a assinatura JWT.

iOS

Para ativar a autenticação do SDK, defina a propriedade configuration.api.sdkAuthentication como true no seu código nativo iOS:

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>

Após ativar a autenticação do SDK na camada nativa, você pode usar os métodos do Flutter SDK mostrados nas etapas seguintes.

A autenticação do SDK deve ser ativada durante a inicialização nativa do SDK. Adicione a seguinte configuração ao seu código nativo iOS e Android:

iOS

Defina a propriedade SDKAuthenticationEnabled como true no seu arquivo de configuração:

1
2

<key>SDKAuthenticationEnabled</key>
<true/>

Android (braze.xml)

1

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

Após ativar a autenticação do SDK na camada nativa, você pode usar os métodos C# do Unity mostrados nas etapas seguintes.

A autenticação do SDK deve ser ativada durante a inicialização nativa do SDK. Adicione a seguinte configuração ao seu código nativo iOS e Android:

iOS

Para ativar a autenticação do SDK, defina a propriedade enableSDKAuthentication como true no seu config.xml:

1

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

Android (braze.xml)

1

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

Após ativar a autenticação do SDK na camada nativa, você pode usar os métodos JavaScript do Cordova mostrados nas etapas seguintes.

A autenticação do SDK deve ser ativada durante a inicialização nativa do SDK. Configure a autenticação do SDK separadamente para iOS e Android:

iOS

Para ativar a autenticação do SDK, defina a propriedade configuration.Api.SdkAuthentication como true ao inicializar o SDK:

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>

Após ativar a autenticação do SDK, você pode usar os métodos .NET MAUI mostrados nas etapas seguintes.

Ao usar o plugin Braze Expo, defina a propriedade enableSdkAuthentication como true na configuração do seu app. Isso configura automaticamente a autenticação do SDK nas camadas nativas iOS e Android sem necessidade de alterações manuais no código nativo.

app.json ou app.config.js

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

{
  "expo": {
    "plugins": [
      [
        "@braze/expo-plugin",
        {
          "enableSdkAuthentication": true
        }
      ]
    ]
  }
}

Após ativar a autenticação do SDK na configuração do seu app, você pode usar os métodos JavaScript do React Native mostrados na guia React Native para as etapas seguintes.

Etapa 2.2: Defina o JWT do usuário atual

Sempre que seu app chamar o método changeUser da Braze, forneça também o JWT que foi gerado no lado do servidor.

Você também pode configurar o token para ser atualizado durante a sessão do usuário atual.

Forneça o JWT ao chamar changeUser:

1
2

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1
2

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

Forneça o JWT ao chamar changeUser:

1
2
3

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

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1
2
3

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

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

Forneça o JWT ao chamar changeUser:

1

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1

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

Forneça o JWT ao chamar changeUser:

1

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1

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

Forneça o JWT ao chamar changeUser:

1

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1

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

Forneça o JWT ao chamar changeUser:

1

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1

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

Forneça o JWT ao chamar changeUser:

1

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1

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

Forneça o JWT ao chamar changeUser:

1
2
3
4

import 'package:braze_plugin/braze_plugin.dart';

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1
2
3
4

import 'package:braze_plugin/braze_plugin.dart';

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

Forneça o JWT ao chamar ChangeUser:

1

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1

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

Forneça o JWT ao chamar changeUser:

1

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1

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

Forneça o JWT ao chamar ChangeUser:

iOS

1

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1

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

Android

1

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1

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

Ao usar o plugin Braze Expo, use os mesmos métodos do SDK React Native. Forneça o JWT ao chamar changeUser:

1
2
3

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

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

Ou, quando você tiver atualizado o token do usuário durante a sessão:

1
2
3

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

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

Etapa 2.3: Registre uma função de retorno de chamada para tokens inválidos

Quando esse recurso está definido como Obrigatório, os seguintes cenários farão com que as solicitações do SDK sejam rejeitadas pela Braze:

  • O JWT estava expirado no momento em que foi recebido pela API da Braze
  • O JWT estava vazio ou ausente
  • O JWT não passou na verificação para as chaves públicas que você carregou no dashboard da Braze

Você pode usar subscribeToSdkAuthenticationFailures para se inscrever e ser notificado quando as solicitações do SDK falharem por um desses motivos. Uma função de retorno de chamada contém um objeto com o errorCode relevante, o reason do erro, o userId da solicitação (o usuário não pode ser anônimo) e o token de autenticação (JWT) que causou o erro.

As solicitações com falha serão periodicamente refeitas até que seu app forneça um novo JWT válido. Se o usuário ainda estiver conectado, você pode usar esse retorno de chamada como uma oportunidade para solicitar um novo JWT do seu servidor e fornecer esse novo token válido ao SDK da Braze.

Quando você receber um erro de autenticação, verifique se o userId no erro corresponde ao seu usuário atualmente conectado, depois busque uma nova assinatura do seu servidor e forneça-a ao SDK da Braze. Você também pode registrar esses erros no seu serviço de monitoramento ou relatório de erros.

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);
});

iOS

Defina o delegate de autenticação do SDK na sua implementação nativa iOS:

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);
  }
}

Android

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);
});

iOS

Defina o delegate de autenticação do SDK na sua instância Braze:

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

Android

1
2
3
4

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

Ao usar o plugin Braze Expo, use os mesmos métodos do SDK React Native:

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

Etapa 3: Ative a autenticação no dashboard

Em seguida, você pode ativar a autenticação no dashboard da Braze para os apps que configurou anteriormente.

Tenha em mente que as solicitações do SDK continuarão a fluir normalmente sem autenticação, a menos que a configuração de autenticação do SDK do app esteja definida como Obrigatório no dashboard da Braze.

Caso algo dê errado com sua integração (por exemplo, seu app está passando tokens incorretamente ao SDK, ou seu servidor está gerando tokens inválidos), desative esse recurso no dashboard da Braze, e os dados voltarão a fluir normalmente sem verificação.

Opções de aplicação

Na página Gerenciar configurações do dashboard, cada app tem três estados de autenticação do SDK que controlam como a Braze verifica as solicitações.

Configuração Descrição
Desativado A Braze não verificará o JWT fornecido para um usuário. (Configuração padrão)
Opcional A Braze verificará as solicitações de usuários conectados, mas não rejeitará solicitações inválidas.
Obrigatório A Braze verificará as solicitações de usuários conectados e rejeitará JWTs inválidos.

Configurações de autenticação do SDK da Braze mostrando as opções de aplicação Desativado, Opcional e Obrigatório.

A configuração Opcional é uma maneira útil de monitorar o impacto potencial que esse recurso terá no tráfego do SDK do seu app.

Um JWT inválido será reportado nos estados Opcional e Obrigatório, porém apenas o estado Obrigatório rejeitará solicitações do SDK, fazendo com que os apps tentem novamente e solicitem um novo JWT.

Gerenciamento de chaves públicas

Adição de uma chave pública

Você pode adicionar até três chaves públicas para cada app: uma primária, uma secundária e uma terciária. Você também pode adicionar a mesma chave a mais de um app, se necessário. Para adicionar uma chave pública:

  1. Acesse o dashboard da Braze e selecione Configurações > Configurações do app.
  2. Escolha um app da sua lista de apps disponíveis.
  3. Em Autenticação do SDK, selecione Adicionar chave pública.
  4. Insira uma descrição opcional, cole sua chave pública e selecione Adicionar chave pública.

Atribuir uma nova chave primária

Para atribuir uma chave secundária ou terciária como sua nova chave primária:

  1. Acesse o dashboard da Braze e selecione Configurações > Configurações do app.
  2. Escolha um app da sua lista de apps disponíveis.
  3. Em Autenticação do SDK, escolha uma chave e selecione Gerenciar > Tornar chave primária.

Exclusão de uma chave

Para excluir uma chave primária, primeiro atribua uma nova primária e, em seguida, exclua sua chave. Para excluir uma chave não primária:

  1. Acesse o dashboard da Braze e selecione Configurações > Configurações do app.
  2. Escolha um app da sua lista de apps disponíveis.
  3. Em Autenticação do SDK, escolha uma chave não primária e selecione Gerenciar > Excluir chave pública.

Análise de dados

Cada app mostrará um detalhamento dos erros de autenticação do SDK coletados enquanto esse recurso estiver no estado Opcional e Obrigatório.

Os dados estão disponíveis em tempo real, e você pode passar o mouse sobre os pontos do gráfico para ver um detalhamento dos erros de uma determinada data.

Um gráfico que mostra o número de instâncias de erros de autenticação. Também são mostrados o número total de erros, o tipo de erro e o intervalo de datas ajustável.

Códigos de erro

Código de erro Motivo do erro Descrição Etapas para resolver
10 EXPIRATION_REQUIRED A expiração é um campo obrigatório para o uso da Braze. Adicione um campo exp ou de expiração à sua lógica de criação de JWT.
20 DECODING_ERROR Chave pública não correspondente ou um erro geral não detectado. Copie seu JWT em uma ferramenta de teste de JWT para diagnosticar por que seu JWT está em um formato inválido.
21 SUBJECT_MISMATCH Os assuntos esperado e real não são os mesmos. O campo sub deve ser o mesmo ID do usuário passado para o método changeUser do SDK.
22 EXPIRED O token fornecido expirou. Prolongue a validade ou atualize periodicamente os tokens antes que eles expirem.
23 INVALID_PAYLOAD A carga útil do token é inválida. Copie seu JWT em uma ferramenta de teste de JWT para diagnosticar por que seu JWT está em um formato inválido.
24 INCORRECT_ALGORITHM O algoritmo do token não é compatível. Altere seu JWT para usar criptografia RS256. Outros tipos não são compatíveis.
25 PUBLIC_KEY_ERROR A chave pública não pôde ser convertida no formato adequado. Copie seu JWT em uma ferramenta de teste de JWT para diagnosticar por que seu JWT está em um formato inválido.
26 MISSING_TOKEN Nenhum token foi fornecido na solicitação. Certifique-se de que está passando um token ao chamar changeUser(id, token) e que seu token não está em branco.
27 NO_MATCHING_PUBLIC_KEYS Nenhuma chave pública corresponde ao token fornecido. A chave privada usada no JWT não corresponde a nenhuma chave pública configurada para o seu app. Confirme se você adicionou as chaves públicas ao app correto em seu espaço de trabalho que corresponde a esta chave de API.
28 PAYLOAD_USER_ID_MISMATCH Nem todos os IDs de usuário na carga útil da solicitação correspondem conforme necessário. Isso é inesperado e pode resultar em uma carga útil malformada. Abra um ticket de suporte para obter assistência.

Perguntas frequentes (FAQ)

Esse recurso precisa ser ativado em todos os meus apps ao mesmo tempo?

Não, esse recurso pode ser ativado para apps específicos e não precisa ser usado em todos os seus apps de uma só vez.

O que acontece com os usuários que ainda estão em versões mais antigas do meu app?

Quando você começar a aplicar esse recurso, as solicitações feitas por versões mais antigas do app serão rejeitadas pela Braze e tentadas novamente pelo SDK. Depois que os usuários fizerem upgrade do app para uma versão compatível, essas solicitações enfileiradas começarão a ser aceitas novamente.

Se possível, incentive os usuários a fazer upgrade como faria para qualquer outra atualização obrigatória. Como alternativa, você pode manter o recurso como Opcional até perceber que uma porcentagem aceitável de usuários fez upgrade.

Que validade devo usar ao gerar um JWT?

Recomendamos usar o valor mais alto entre: duração média da sessão, expiração do cookie/token da sessão ou a frequência com que o aplicativo atualizaria o perfil do usuário atual.

O que acontece se um JWT expirar no meio da sessão de um usuário?

Caso o token de um usuário expire no meio da sessão, o SDK possui uma função de retorno de chamada que será invocada para informar ao seu app que um novo JWT é necessário para continuar enviando dados para a Braze.

O que acontecerá se minha integração no lado do servidor falhar e eu não puder mais criar um JWT?

Se o seu servidor não conseguir fornecer um JWT ou se você notar algum problema de integração, você sempre pode desativar o recurso no dashboard da Braze.

Uma vez desativado, o SDK eventualmente tentará novamente as solicitações pendentes que falharam, e a Braze as aceitará.

Por que esse recurso usa chaves pública/privada em vez de segredos compartilhados?

Ao usar segredos compartilhados, qualquer pessoa com acesso a esse segredo compartilhado, como a página do dashboard da Braze, poderá gerar tokens e se passar por seus usuários finais.

Em vez disso, usamos chaves pública/privada para que nem mesmo os colaboradores da Braze (muito menos os usuários da sua empresa) tenham acesso às suas chaves privadas.

Como as solicitações rejeitadas serão tentadas novamente?

Quando uma solicitação é rejeitada devido a um erro de autenticação, o SDK invocará seu retorno de chamada usado para atualizar o JWT do usuário.

As solicitações serão repetidas periodicamente usando uma abordagem de backoff exponencial. Após 50 tentativas consecutivas sem sucesso, as novas tentativas serão pausadas até o início da próxima sessão. Cada SDK também tem um método para solicitar manualmente uma descarga de dados.

É possível usar a autenticação do SDK para usuários anônimos?

Não. A autenticação do SDK funciona com seu site confirmando a identidade de alguém, então ela se aplica apenas a usuários identificados. Como usuário anônimo, não há identidade a ser confirmada.

A aplicação começa após a chamada de changeUser. Antes de um usuário ser identificado (por exemplo, enquanto navega anonimamente antes de se cadastrar), o SDK ainda pode enviar dados para a Braze sem um JWT. Após a chamada de changeUser, as solicitações para esse perfil identificado exigem um JWT válido.

Isso significa que uma jornada típica de usuário pode ser assim:

  1. Um usuário visita seu site ou abre seu app anonimamente. A Braze coleta essa atividade sem um JWT.
  2. O usuário se cadastra ou faz login, e seu app chama changeUser com um external_id.
  3. A Braze continua coletando atividade para esse usuário, e a autenticação do SDK é aplicada para solicitações desse perfil identificado.

A autenticação do SDK funciona com aliases de usuário?

Não. A autenticação do SDK requer um external_id. Não é possível configurá-la quando apenas um braze_id ou alias_id está disponível, então perfis somente com alias não podem usar a autenticação do SDK.

Ativar a autenticação do SDK bloqueia a coleta de atividade não autenticada?

Não. A autenticação do SDK não bloqueia a coleta legítima de atividade anônima. Ela se aplica apenas após um perfil ser identificado com changeUser.
New Stuff!