Ajouter une licence logicielle à une application Go

1. Préparez un produit et une licence

Utilisez ce chemin pour un utilitaire de bureau, une application de ligne de commande ou un service nécessitant une licence verrouillée par nœud. Commencez par une fonctionnalité d'exportation illimitée afin de pouvoir vérifier les licences avant d'ajouter des compteurs d'utilisation.

Le quota compte les activations actuelles et est rendu à leur libération. Les licences ordinaires restent comptées hors ligne ; les licences flottantes rendent aussi le quota à l’expiration du bail.

1. Copiez l’ID du produit dans Console > Produits. Ouvrez les clés publiques de signature du même produit et collez toutes les paires ID de clé/clé publique dans le code d’initialisation, en remplaçant YOUR_PRODUCT_ID, YOUR_KEY_ID et YOUR_PUBLIC_KEY. L’intégration rapide peut générer ce code. Aucun fichier de configuration n’est nécessaire ; le SDK utilise https://www.licentivo.com par défaut.
2. Installez Go 1.26 ou version ultérieure. Dans la console, ouvrez Intégration rapide et créez un produit.
3. Activez une fonctionnalité nommée exportation dans la stratégie d'autorisation du produit. Créez ou sélectionnez une licence de test.

2. Installez le SDK dans votre projet

Installez le SDK 0.11.6 avec la commande suivante dans votre projet ou ajoutez la dépendance de compilation. Le gestionnaire de paquets récupère le SDK ; aucun ZIP source, aucune extraction manuelle ni aucun chemin local ne sont nécessaires.

go get github.com/spf86/licentivo-sdk@v0.11.6

3. Protégez une opération

Initialisez le SDK au démarrage ou lors de l’activation de votre logiciel. Lisez la clé client dans votre formulaire et transmettez l’ID produit et les clés approuvées. Gardez le client jusqu’à la fermeture. Placez RunFeature au point d’entrée métier réel et remplacez l’export par votre fonction.

// One protected operation. Keep the client alive for the lifetime of your app.
package main

import (
	"context"
	"fmt"
	licentivo "github.com/spf86/licentivo-sdk"
	"os"
)

// BEGIN LICENTIVO PRODUCT
// Copy Product ID and all key ID/public key pairs from Console > Products > Signing public keys.
const productID = "YOUR_PRODUCT_ID"

var trustedKeys = map[string]string{"YOUR_KEY_ID": "YOUR_PUBLIC_KEY"}

// END LICENTIVO PRODUCT

func setting(name, fallback string) string {
	if value := os.Getenv(name); value != "" {
		return value
	}
	return fallback
}

// Call this at the business entry point, including keyboard/menu/CLI actions.
func exportReport(path string) error {
	// Replace this write with your existing, non-metered export operation.
	return os.WriteFile(path, []byte("A report generated by the licensed application.\n"), 0600)
}

func run() error {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	// In a GUI, obtain key from the activation input. Later starts use an empty key.
	client, err := licentivo.OpenProduct(ctx, productID, trustedKeys, os.Getenv("LICENTIVO_LICENSE_KEY"), func(err error) {
		fmt.Fprintln(os.Stderr, "Background verification:", err)
	})
	if err != nil {
		return err
	}
	defer client.Close() // Floating seats return; node-locked registration stays.
	feature := setting("LICENTIVO_FEATURE", "export")
	path := setting("LICENTIVO_OUTPUT", "licensed-report.txt")
	action := func() error { return exportReport(path) }
	if os.Getenv("LICENTIVO_METERED") == "1" {
		err = client.RunMeteredFeature(ctx, feature, 1, os.Getenv("LICENTIVO_OPERATION_ID"), action)
	} else {
		err = client.RunFeature(feature, action)
	}
	if err != nil {
		return err
	}
	fmt.Printf("License OK: %s is available\nExport completed: %s\n", feature, path)
	return nil
}

func main() {
	if err := run(); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(2)
	}
}

4. Conservez un client pendant toute la durée de vie de l'application

Dans une application réelle, ouvrez le client au démarrage et placez RunFeature dans le bouton d'exportation ou le gestionnaire de commandes. Gardez le client en vie jusqu'à l'arrêt. La fermeture arrête le travail en arrière-plan ; il préserve l'enregistrement ordinaire verrouillé par nœud.

Le SDK stocke un identifiant lié à la machine après l'activation. Les démarrages ultérieurs peuvent transmettre une clé vide et la restaurer à partir du même compte utilisateur et du même emplacement de cache. Vous n'avez pas besoin de stocker les identifiants d'activation ni d'envoyer vous-même HTTP heartbeats.

Un bail hors ligne valide verrouillé par nœud peut être restauré immédiatement tandis que le SDK s'actualise en ligne en arrière-plan. Une stratégie flottante ou en ligne uniquement nécessite une réponse réussie du serveur. Ne traitez jamais une erreur en arrière-plan enregistrée comme une autorisation de contourner une vérification de fonctionnalité ayant échoué.

5. Vérifiez les opérations autorisées et refusées

1. Exécutez une fois avec la clé de test et confirmez que le rapport existe.
2. Supprimez LICENTIVO_LICENSE_KEY et réexécutez sous le même utilisateur : les informations d'identification enregistrées doivent être restaurées.
3. Changer l'export vers une fonctionnalité absente de la licence : l'opération doit retourner une erreur sans rédiger de rapport.
4. Vérifiez un redémarrage hors ligne uniquement lorsque la stratégie le permet et que le bail signé est toujours valide.

Problèmes d'intégration courants

Vérifiez l’ID produit, toutes les paires ID de clé/clé publique et la licence du client. Les clés publiques appartiennent au produit ; licences et identifiants des appareils sont distincts. Ne distribuez pas de clés de test ou de clés API de gestion.

Une fonctionnalité refusée nécessite de vérifier le nom de la fonctionnalité et la politique de licence ; RunFeature vérifie les droits, et non l'utilisation restante. Utilisez RunMeteredFeature pour un compteur.

Les limites des appareils, une licence expirée ou un refus explicite du serveur nécessitent que le client ou le fournisseur résolve l'autorisation. Afficher l'erreur et l'ID de la demande, le cas échéant. N'incluez jamais les clés de gestion des fournisseurs dans l'application.