# Identités de client et protocoles

> Créez une identité de client, rechargez-la et voyez quels protocoles elle peut utiliser.

Source: https://docs.thalovant.com/fr/developers/sdk-functions/client-identities/

---
{/* Last Edit: Claude Opus 5.5 - 2026-09-28 - Motive: Canadian French translation of developers/sdk-functions/client-identities.mdx. */}

Fait partie de [Fonctions des SDK](/fr/developers/sdk-functions/). 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
```

  
  

```ts
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
```

  
  

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

var identity = result.Identity;
```

  

  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 :

```bash
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()
```

  
  

```ts

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)
```

  
  

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