Licence flottante

Une licence flottante est un pool de licences partagé entre les utilisateurs ou les machines d’un réseau. Avec Babel Licensing, vous créez les licences flottantes dans le Babel Licensing Service à l’aide de Babel Desktop. Cette page montre comment créer une licence flottante avec Babel Desktop et comment configurer une application cliente .NET pour qu’elle l’utilise avec la bibliothèque Babel Licensing.

Prérequis

Pour mettre en place les licences flottantes dans le Babel Licensing Service, procédez comme suit. Vérifiez d’abord que le Babel Licensing Service est opérationnel sur votre serveur, conformément aux instructions de la section Premiers pas. Créez ensuite un produit de test et le modèle de licence correspondant en suivant les instructions ci-dessous. Vous disposerez ainsi de la base nécessaire pour générer des licences flottantes.

Vous devez aussi télécharger depuis GitHub le code source du client de licence flottante. Ce code client servira à intégrer les licences flottantes à votre application .NET.

git clone https://github.com/babelfornet/floating-license-console-example.git

Pour cet exemple, la création d’une licence flottante nécessite la création du modèle de licence correspondant.

Créer une licence flottante

Babel Desktop se connecte au Babel Licensing Service et vous permet de créer et de configurer des licences flottantes. Vous définissez la taille du pool de licences, c’est-à-dire le nombre d’utilisateurs ou de machines autorisés à utiliser la licence en même temps. Votre application acquiert ensuite une licence du pool lorsqu’elle en a besoin et la libère lorsqu’elle a terminé. Chaque poste emprunté est un jeton qui compte dans la limite de jetons du service ; voir Jetons de licence.

Pour enregistrer une licence flottante dans Babel Desktop, procédez comme suit :

La licence flottante que vous venez d’enregistrer apparaît maintenant dans la grille des licences, avec une clé de licence unique et d’autres informations utiles. Avec l’édition Data Center, vous pouvez aussi créer des licences flottantes sur la page Licences de l’application web.

Le Babel Licensing Service limite l’utilisation simultanée de la licence au nombre de sites flottants que vous avez saisi.

Configurer un client

Une fois la licence flottante créée dans le Babel Licensing Service, vous devez configurer votre application cliente .NET pour qu’elle utilise la licence. Il s’agit d’intégrer la bibliothèque Babel Licensing à votre application et d’écrire le code nécessaire pour demander et libérer des licences du pool de licences flottantes. La bibliothèque Babel Licensing fournit les API de validation et de contrôle des licences.

Pour ouvrir le projet d’exemple de licence flottante, procédez comme suit :

Ouvrir la solution

Accédez à l’emplacement du projet d’exemple de licence flottante et double-cliquez sur le fichier de solution ClientFloating.sln pour l’ouvrir dans votre environnement de développement intégré (IDE), par exemple Visual Studio.

Vérifier la référence à la bibliothèque cliente

Une fois le projet ouvert, vérifiez que la bibliothèque cliente Babel Licensing est correctement référencée. Si la référence est absente, reportez-vous au paragraphe Composants client pour configurer un dépôt NuGet local.

Générer la solution

Une fois les références vérifiées, générez la solution en sélectionnant l’option « Build » (Générer) ou « Rebuild » (Régénérer) dans le menu de l’IDE.

Exécuter l’application

Une fois la solution générée, vous pouvez exécuter l’application en configuration de débogage en cliquant sur le bouton « Start Debugging » (Démarrer le débogage) ou en utilisant le raccourci clavier de votre IDE (par exemple F5 dans Visual Studio). L’application d’exemple de licence flottante démarre : vous pouvez alors utiliser les fonctionnalités de licence et tester le flux de travail de licence flottante.

Saisir la clé de licence flottante

Saisissez la clé de licence flottante générée pour la licence et appuyez sur ENTER.

Voici le code source complet de l’exemple de licence flottante :

using Babel.Licensing;
 
// Create a new configuration object
BabelLicensingConfiguration config = new BabelLicensingConfiguration() {
    // Set the service URL
    ServiceUrl = "http://localhost:5005",
    
    // Set the public key used to verify the license signature
    SignatureProvider = RSASignature.FromKeys("MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDE1VRiIdr6fiVZKve7NVgjIvGdRiRx0Mjjm+Yzf6tLbzFnxLs0fat5EoRcubxx0QQQDfydsJBE/fc7cwRWSrE2xK6X4Eb4W8O47pCMjqvTQZfDqQywEZJrLlxpp9hlKz6FDYX4SagrjmP1gdw8olo+n+IBz8ubkNxRhvycikxuDQIDAQAB"),
    
    // Set a unique client ID in case multiple instances of the application are running on the same machine
    ClientId = Guid.NewGuid().ToString()
};
 
// Create the client object used to communicate with the server
BabelLicensing client = new BabelLicensing(config);
 
// Ask the user to enter the floating license key
Console.WriteLine("Please enter your floating license key: ");
string? userKey = Console.ReadLine();
 
try
{
    var result = await client.RequestFloatingLicenseAsync(userKey, typeof(Program));
 
    Console.WriteLine($"License {result.License.Id} requested.");
}
catch (Exception ex)
{
    Console.WriteLine($"Could not request floating license: {ex.Message}");
    return;
}
 
try
{
    // Simulate a long task which requires the allocation of a license
    for (int i = 0; i < 10; i++)
    {
        // Validate the license
        // This will contact the server to validate the license
        var result = await client.ValidateLicenseAsync(userKey, typeof(Program));
        Console.WriteLine($"{i}) License {result.License.Id} valid.");
 
        // Wait 1 second
        await Task.Delay(1000);
    }
 
    try
    {
        // Release the license to allow other clients to use it
        await client.ReleaseFloatingLicenseAsync(userKey);
        Console.WriteLine("License released.");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Could not release license: {ex.Message}");
    }
 
}
catch (Exception ex)
{
    Console.WriteLine($"License not valid: {ex.Message}");
    return;
}
 

La classe BabelLicensing est instanciée pour communiquer avec le serveur de licences. La clé publique servant à valider la licence est définie dans la configuration du service, de même que l’URL de communication avec le service.

L’utilisateur est invité à saisir la clé de licence flottante. Le client utilise cette clé pour demander une licence flottante en appelant la méthode RequestFloatingLicenseAsync. La clé utilisateur et le type du programme sont passés en paramètres. En cas de réussite, la méthode renvoie un objet résultat qui contient les informations de la licence demandée.

Le code simule une tâche longue qui a besoin de la licence allouée. Dans une boucle, la licence est validée avec la méthode ValidateLicenseAsync. La clé utilisateur et le type du programme sont passés en paramètres. Si la licence est valide, la méthode renvoie un objet résultat qui contient les informations de la licence. La boucle comprend aussi un délai d’une seconde pour simuler la durée de la tâche.

Une fois la tâche terminée, le client libère la licence flottante avec la méthode ReleaseFloatingLicenseAsync.

Les licences flottantes permettent de partager un nombre limité de licences sur un réseau d’utilisateurs ou de machines, avec moins de travail d’administration que l’attribution d’une licence à chacun. Elles conviennent à une base d’utilisateurs en croissance, ou à des licences partagées entre services ou équipes.