Richiedere connessioni autorizzate

La chiave app è pubblica. Chiunque possa caricare la tua pagina può usarla per aprire una connessione e sottoscrivere canali pubblici.

Le connessioni autorizzate richiedono che ogni nuova connessione dimostri di essere autorizzata entro 30 secondi. L'edge Realtime chiude le connessioni che non si autorizzano in tempo.

Richiedere connessioni autorizzate

Abilita Authorized connections per l'app nella pagina Realtime apps. Puoi anche impostare authorized_connections su true tramite la API Realtime. L'impostazione si applica a ogni connessione che usa una delle chiavi dell'app.

Aggiorna i client per autorizzarsi prima di abilitare l'impostazione in produzione. Le connessioni stabilite prima dell'abilitazione restano aperte, ma le connessioni successive da client più vecchi falliscono dopo il timeout di autorizzazione.

Cosa conta come autorizzato

Una nuova connessione parte non autorizzata. Una di queste azioni la autorizza:

Una sottoscrizione private o presence riesce. Il client invia il connection ID al tuo authEndpoint, il tuo backend lo firma e l'edge verifica la firma. Vedi Autorizzazione dei canali.
signin() riesce. Il client invia il connection ID al tuo memberAuthEndpoint e riceve un'identità membro firmata. Vedi Terminare le connessioni di un membro per il flusso completo di sign-in.

Entrambi i percorsi dimostrano la stessa cosa: qualcosa che possiede il secret dell'app ha garantito per questa connessione. Sottoscrivere un canale pubblico non dimostra nulla e non autorizza niente.

Il caso solo canali pubblici

Un client che sottoscrive solo canali pubblici normalmente non contatta il tuo backend. Dopo aver richiesto connessioni autorizzate, chiama signin() così la connessione può autorizzarsi senza una sottoscrizione private:

import { BirdRealtime } from "@messagebird/realtime";

const bird = new BirdRealtime({
  appKey: "your-app-key",
  region: "us1",
  memberAuthEndpoint: "/bird/auth/member",
});

await bird.signin();

const status = bird.subscribe("build-status");
status.bind("build-finished", (data) => render(data));

import BirdRealtime

let bird = BirdRealtime(options: .init(
    appKey: "your-app-key",
    region: "us1",
    memberAuthEndpoint: URL(string: "https://your-backend.example.com/bird/auth/member")
))

try await bird.signin()

let status = bird.subscribe("build-status")
status.bind("build-finished") { data in
    render(data)
}

import com.bird.realtime.BirdRealtime
import com.bird.realtime.BirdRealtimeOptions

val bird = BirdRealtime(
    BirdRealtimeOptions(
        appKey = "your-app-key",
        region = "us1",
        memberAuthEndpoint = "https://your-backend.example.com/bird/auth/member",
    )
)

bird.signin() // suspending

val status = bird.subscribe("build-status")
status.bind("build-finished") { data ->
    render(data)
}

Chiama signin() una sola volta. Il client effettua di nuovo il sign-in dopo ogni riconnessione perché l'identità appartiene alla connessione. Restituisci 403 Forbidden dal tuo endpoint di autorizzazione membro quando il chiamante non deve connettersi.

Se l'app sottoscrive un canale private o presence al caricamento, la sottoscrizione riuscita autorizza già la connessione.

Cosa vede il client quando non si autorizza

L'edge chiude la connessione con il codice 4009 e il motivo Connection not authorized within timeout. I client non riprovano i codici in questo intervallo, quindi la connessione entra nello stato failed.

bird.connection.bind("error", ({ code, message }) => {
  if (code === 4009) console.warn(message);
});

bird.onError { error in
    if error.code == 4009 { print(error.message) }
}

bird.onError { error ->
    if (error.code == 4009) println(error.message)
}

Il codice 4009 identifica anche un membro le cui connessioni sono state terminate dal tuo backend. Controlla il motivo prima di scegliere uno stato di login o signed-out. Vedi Terminare le connessioni di un membro e Ciclo di vita della connessione e riconnessione.

Le connessioni non contano nella quota di connessioni dell'app finché non si autorizzano.

Ambito dell'autorizzazione

Richiedere connessioni autorizzate controlla chi può mantenere aperta una connessione. Non sostituisce i controlli di autorizzazione e non cambia chi può leggere un canale:

Un canale pubblico resta pubblico per ogni connessione autorizzata. Se gli eventi appartengono a un singolo cliente, usa un canale private e verifica il nome del canale nel tuo endpoint.
Chiunque i tuoi endpoint di autenticazione firmino risulta autorizzato, quindi un endpoint permissivo distribuisce autorizzazioni con la stessa libertà della chiave app.

Passaggi successivi

Autorizzazione dei canali è la firma che il tuo backend calcola per le sottoscrizioni private e presence.
Canali private sono lo strumento giusto quando gli eventi stessi appartengono a qualcuno.
Terminare le connessioni di un membro copre signin() e l'altro uso di 4009.
Inviare eventi a un membro indirizza un evento a un'identità con sign-in invece che a un canale.
Ciclo di vita della connessione e riconnessione spiega perché 4009 è terminale.

Risorse correlate

Prosegui con la documentazione, le guide e gli esempi per questo argomento. Le risorse sono in inglese.

Esplora la funzionalitàRealtime Segui il percorso di apprendimentoBuild your first integration Guida all'implementazioneSend your first realtime event

Prova l'esercitazione e ottieni un brief di implementazione