Identités de client et protocoles

Fait partie de Fonctions des SDK. Chaque appel ci-dessous est montré dans chaque langage qui l’offre.

Créer une identité de client

Créez une identité quand un navigateur, un service, un client vocal, un appareil ou un agent doit se connecter à un hub.

Python

result = api.create_client_identity(
    "hub-id",
    name="checkout-kiosk",
    preferred_protocols=("wss", "https"),
)

identity = result.identity

Node.js

const result = await api.createClientIdentity("hub-id", {
  name: "checkout-kiosk",
  preferredProtocols: ["wss", "https"],
});

const identity = result.identity;

Go

result, err := api.CreateClientIdentityForHubID(ctx, "hub-id", thalovant.BootstrapIdentityOptions{
  Name:               "checkout-kiosk",
  PreferredProtocols: []thalovant.HubProtocol{thalovant.ProtocolWSS, thalovant.ProtocolHTTPS},
})
if err != nil {
  log.Fatal(err)
}

identity := result.Identity

Rust

let result = api
    .create_client_identity_for_hub_id(
        "hub-id",
        BootstrapIdentityOptions {
            name: "checkout-kiosk".into(),
            preferred_protocols: vec![HubProtocol::Wss, HubProtocol::Https],
            ..Default::default()
        },
    )
    .await?;

let identity = result.identity.clone();

Kotlin

val result = api.createClientIdentity(
    "hub-id",
    CreateClientIdentityOptions(name = "checkout-kiosk"),
)

val identity = result.identity

Swift

let result = try await api.createClientIdentity(
    hubId: "hub-id",
    options: CreateClientIdentityOptions(name: "checkout-kiosk")
)

let identity = result.identity

C#

var result = await api.CreateClientIdentityAsync(
    "hub-id",
    new CreateClientIdentityOptions("checkout-kiosk"));

var identity = result.Identity;

Attention

N’écrivez pas l’identité complète dans les journaux. Conservez-la comme un secret, car elle contient les éléments de connexion du client.

Chaque SDK accepte aussi une option active à la création, qui vaut « true » par défaut. Passez « false » pour provisionner le client désactivé : il ne pourra pas se connecter tant que vous ne l’aurez pas activé par une mise à jour du client.

Charger les éléments d’identité

Utilisez la configuration ou un fichier d’identité téléchargé quand le client existe déjà.

Sous Linux et macOS, protégez les fichiers locaux config.yaml et _identity.json avec des permissions réservées au propriétaire avant de les charger :

chmod 600 ~/.config/thalovant/config.yaml
chmod 600 _identity.json

Python

from thalovant import ThalovantClient, ThalovantIdentity

identity = ThalovantIdentity.from_config(profile="prod")
same_identity = ThalovantIdentity.from_file("_identity.json")

client_from_config = ThalovantClient.from_config(profile="prod", protocol="wss")
client_from_file = ThalovantClient.from_identity_file("_identity.json")
client_from_env = ThalovantClient.from_env()

Node.js

const identity = await ThalovantIdentity.fromConfig({ profile: "prod" });
const sameIdentity = await ThalovantIdentity.fromFile("_identity.json");

const clientFromConfig = await ThalovantClient.fromConfig({ profile: "prod", protocol: "wss" });
const clientFromFile = await ThalovantClient.fromIdentityFile("_identity.json");
const clientFromEnv = ThalovantClient.fromEnv();

Go

identity, err := thalovant.IdentityFromConfig("", "prod")
if err != nil {
  log.Fatal(err)
}

sameIdentity, err := thalovant.IdentityFromFile("_identity.json")
if err != nil {
  log.Fatal(err)
}

clientFromConfig, err := thalovant.NewClientFromConfig("", "prod")
clientFromFile, err := thalovant.NewClientFromFile("_identity.json")
clientFromEnv, err := thalovant.NewClientFromEnv()

Rust

use thalovant::{Client, Identity};

let identity = Identity::from_config(Some("prod"))?;
let same_identity = Identity::from_file("_identity.json")?;

let client_from_config = Client::from_config(Some("prod"))?;
let client_from_file = Client::from_file("_identity.json")?;
let client_from_env = Client::from_env()?;

Inspecter les protocoles

Utilisez les fonctions d’aide sur les protocoles avant d’imposer WSS, HTTPS ou MQTT.

Python

print(identity.enabled_protocols())
print(identity.endpoint_for("wss"))
print(identity.endpoint_for("https"))
print(identity.endpoint_for("mqtt"))
print(identity.supports_protocol("wss"))

if identity.mqtt:
    print(identity.mqtt.endpoint)

Node.js

console.log(identity.enabledProtocols());
console.log(identity.endpointFor("wss"));
console.log(identity.endpointFor("https"));
console.log(identity.endpointFor("mqtt"));
console.log(identity.supportsProtocol("wss"));

if (identity.mqtt) {
  console.log(identity.mqtt.endpoint);
}

Go

fmt.Println(identity.EnabledProtocols())
fmt.Println(identity.EndpointFor(thalovant.ProtocolWSS))
fmt.Println(identity.EndpointFor(thalovant.ProtocolHTTPS))
fmt.Println(identity.EndpointFor(thalovant.ProtocolMQTT))
fmt.Println(identity.SupportsProtocol(thalovant.ProtocolWSS))

if identity.MQTT != nil {
  fmt.Println(identity.MQTT.Endpoint)
}

Rust

println!("{:?}", identity.enabled_protocols());
println!("{:?}", identity.endpoint_for(HubProtocol::Wss));
println!("{:?}", identity.endpoint_for(HubProtocol::Https));
println!("{:?}", identity.endpoint_for(HubProtocol::Mqtt));
println!("{}", identity.supports_protocol(HubProtocol::Wss));

if let Some(mqtt) = &identity.mqtt {
    println!("{}", mqtt.endpoint);
}