Aller au contenu principal

Initialiser ton compte de service Qiskit Runtime

Avant d'utiliser Qiskit Runtime, tu dois initialiser (instancier) ton compte en soumettant (chargeant) tes identifiants. Ces identifiants peuvent être soumis manuellement à chaque fois que tu initialises le service Qiskit Runtime, ou tu peux les enregistrer pour les réutiliser.

Remarques

Avant de commencer​

Assure-toi d'avoir effectué les étapes suivantes :

  1. Assure-toi d'être membre d'un compte IBM Cloud. Consulte Configurer ton compte IBM Cloud pour les instructions.
  2. Crée (ou accède à) au moins une instance. Suis ces étapes pour vérifier :
    1. Connecte-toi à IBM Quantum Platform.
    2. Assure-toi que le bon compte et la bonne région sont sélectionnés dans le sélecteur de compte dans l'en-tête.
    3. Si une ou plusieurs instances sont affichées, cette étape est terminée. Sinon, crée une instance.
  3. Assure-toi de travailler dans un environnement Python actif avec le SDK Qiskit et Qiskit Runtime installés.
  4. Active l'environnement virtuel Python et exécute Python dans ton environnement virtuel.

Trouver tes identifiants d'accès​

  1. Trouve ta clé API (également appelée jeton API). Depuis le tableau de bord, crée ta clé API, puis copie-la dans un endroit sécurisé pour pouvoir l'utiliser pour l'authentification. Le jeton ne sera plus visible par la suite. Note que tu peux utiliser une seule clé API pour te connecter à n'importe quelle région.
  2. Facultatif : Trouve l'instance que tu souhaites utiliser depuis la page Instances. Survole son CRN, clique sur l'icône pour le copier, puis enregistre-le dans un endroit sécurisé pour pouvoir l'utiliser pour identifier l'instance.

Connecter Qiskit à ton instance de service Qiskit Runtime​

remarque

Ces instructions sont conçues pour qiskit_ibm_runtime v0.42 ou une version ultérieure. Certaines fonctionnalités ne sont pas disponibles dans les versions antérieures de qiskit_ibm_runtime. Dans ces cas, tu dois toujours fournir une valeur pour channel, token et instance, soit explicitement, soit via un compte enregistré.

Voici le code de base pour connecter Qiskit à ton instance de service Qiskit Runtime. Il existe cependant plusieurs façons de personnaliser les options de QiskitRuntimeService selon tes besoins. Ces options sont décrites dans les sections suivantes.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService(channel=<channel>,
            token=<your-API_KEY>, # Use the 44-character API_KEY you created and saved from the IBM Quantum Platform Home dashboard
            instance=<instance_CRN>)
remarque

Le canal par défaut est ibm_quantum_platform. Comme c'est presque toujours le canal approprié, il n'est pas inclus dans les exemples.

Démarrage rapide : Spécifier les identifiants explicitement​

La façon la plus rapide d'obtenir une instance QiskitRuntimeService opérationnelle est la méthode d'instanciation directe : fournir explicitement le jeton API (clé) et le CRN (identifiant d'instance) à chaque fois que tu as besoin d'initialiser le service Qiskit Runtime. Consulte Trouver tes identifiants d'accès si nécessaire.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService(token=<cloud_api_key>, # Use the 44-character API_KEY you created and saved from the IBM Quantum Platform Home dashboard
            instance=<instance_CRN>)

Cette approche est fiable, mais peut être fastidieuse si tu dois charger les mêmes informations à plusieurs reprises. Pour éviter de charger tes identifiants plusieurs fois, si tu travailles dans un environnement Python de confiance (par exemple sur un ordinateur portable personnel ou un poste de travail), tu peux utiliser des identifiants de compte enregistrés, comme décrit dans la section suivante.

Bien que le paramètre d'entrée instance soit facultatif, il est recommandé de toujours fournir cette information, sauf si tu souhaites utiliser un seul service pour travailler avec plusieurs instances. Dans ce cas, consulte la section sélection automatique d'instance.

Démarrage rapide : Spécifier des identifiants enregistrés​

Si tu as déjà enregistré tes identifiants, utilise le code suivant pour appliquer tes identifiants par défaut. Pour les instructions d'enregistrement des identifiants, consulte Enregistrer tes identifiants d'accès.

from qiskit_ibm_runtime import QiskitRuntimeService

# run every time you need the service
service = QiskitRuntimeService()
...

Si tu as nommé un ou plusieurs ensembles d'identifiants — par exemple pour l'accès ouvert et l'accès premium — utilise le code suivant pour utiliser un ensemble d'identifiants nommé.

from qiskit_ibm_runtime import QiskitRuntimeService

# run every time you need the service
service = QiskitRuntimeService(name="<name_of_saved_credentials>")
...

Considérations lors du chargement des identifiants enregistrés​

  • Si tu initialises un service avec token et name, le token est ignoré et les détails enregistrés du compte name sont chargés.

    Dans l'exemple suivant, le service charge les détails de account_A et n'utilise pas token_B :

    from qiskit_ibm_runtime import QiskitRuntimeService

    service = QiskitRuntimeService(token="token_B", name="account_A")

  • Si tu fournis un name et une instance lors de l'initialisation d'un service, le service essaie de charger le compte name et de se connecter à l'instance spécifiée. En cas de conflit, un avertissement est émis.

    Dans l'exemple suivant, le service tente de charger les identifiants pour account_A et d'utiliser l'instance CRN_B — même si une instance différente est spécifiée dans account_A :

    from qiskit_ibm_runtime import QiskitRuntimeService

    service = QiskitRuntimeService(instance="CRN_B", name="account_A")

  • Le service tente de charger le compte enregistré par défaut uniquement si tu ne fournis ni token ni name lors de l'initialisation. Cependant, si une instance est fournie explicitement, le service tente de se connecter à cette instance en utilisant les identifiants par défaut. En cas de conflit, un avertissement est émis.

    Dans l'exemple suivant, le service tente de charger les identifiants par défaut et d'utiliser l'instance CRN_B — même si une instance différente est spécifiée dans le compte par défaut :

    from qiskit_ibm_runtime import QiskitRuntimeService

    service = QiskitRuntimeService(instance="CRN_B")

  • Si tu enregistres plusieurs ensembles d'identifiants sans en spécifier un lors de l'initialisation du service et qu'il n'y a pas de compte par défaut enregistré, celui dont le nom vient en dernier dans l'ordre alphabétique est utilisé.

    Dans l'exemple suivant, l'utilisateur a enregistré des comptes nommés « my_premium » et « my_open » sans en marquer aucun comme défaut. Il a ensuite initialisé le service avec le code suivant. Dans ce cas, les identifiants « my_premium » sont utilisés :

    from qiskit_ibm_runtime import QiskitRuntimeService

    service = QiskitRuntimeService()

  • Si tu obtiens de façon persistante l'erreur « 401 Unauthorized », tu essaies peut-être d'utiliser un jeton bearer au lieu de ta clé API.

Sélectionner automatiquement l'instance​

Si tu fournis un jeton mais ne fournis pas de CRN d'instance lors de l'instanciation du service, QiskitRuntimeService s'authentifie auprès du compte identifié par le jeton et utilise la sélection automatique d'instance pour choisir l'instance la plus pertinente pour la tâche demandée. Si tu disposes de plusieurs instances dans ton compte, le service choisit automatiquement parmi les instances disponibles, en fonction de la ressource demandée et de ces options QiskitRuntimeService (si définies) : plans_preference, region, tags.

  • plans_preference : Les types de plans d'instance à prioriser. Par exemple, si [open] est passé, seules les instances du plan Open sont disponibles. Les valeurs acceptées sont open, premium, pay-as-you-go, flex et on-prem. Si plans_preference n'est pas spécifié, les plans gratuits sont prioritaires sur les plans payants.
  • region : La région de l'instance. Les valeurs acceptées sont us-east et eu-de.
  • tags : Les tags de l'instance. Accepte une liste de chaînes de noms de tags.
remarque

Tu peux configurer tes identifiants enregistrés pour sélectionner automatiquement une instance.

L'instance est trouvée et utilisée dans cet ordre :

  1. Si ton compte n'a accès qu'à une seule instance, elle est sélectionnée par défaut.
  2. Si des identifiants enregistrés sont utilisés et qu'une instance a été spécifiée avec les identifiants, cette instance est utilisée. Consulte Considérations lors du chargement des identifiants enregistrés.
  3. Si ton compte dispose de plusieurs instances pouvant accéder au QPU demandé, le système utilise tes préférences de plan spécifiées pour choisir un plan et une instance. Pour Qiskit Runtime v0.42 et versions ultérieures, les plans gratuits sont prioritaires par défaut.
  4. Si ton compte a accès à plusieurs instances mais qu'une seule peut accéder au QPU demandé, l'instance disposant de l'accès est sélectionnée. Si cette instance n'est pas associée à un plan gratuit, des frais seront engagés.

Exemples​

Dans cet exemple, le service recherche toutes les instances disponibles pour le compte afin de trouver celles qui peuvent accéder au backend spécifié :

service = QiskitRuntimeService(token=<your-API_KEY>)

Dans cet exemple, le service recherche toutes les instances disponibles pour le compte dans la région UE afin de trouver celles qui peuvent accéder au backend spécifié :

service = QiskitRuntimeService(token=<your-API_KEY>, region="eu-de")

Dans cet exemple, le service recherche toutes les instances disponibles pour le compte et étiquetées services afin de trouver celles qui peuvent accéder au backend spécifié :

service = QiskitRuntimeService(token=<your-API_KEY>, tags=['services'])

Dans cet exemple, le service recherche toutes les instances premium et open disponibles pour le compte afin de trouver celles qui peuvent accéder au backend spécifié. Si un backend est disponible à la fois dans une instance Premium et une instance Open Plan, l'instance Premium Plan est prioritaire car premium est spécifié en premier dans plans_preference.

service = QiskitRuntimeService(token=<your-API_KEY>, plans_preference=['premium', 'open'])

Déterminer quelle instance a été choisie​

L'instance sélectionnée est retournée sous forme d'avertissement. De plus, tu peux exécuter service.active_instance() pour déterminer l'instance active.

Tests locaux avec Qiskit Runtime​

La classe QiskitRuntimeService peut être initialisée avec channel=local pour effectuer une simulation locale. Dans ce cas, l'authentification n'est pas requise et il n'est pas nécessaire de fournir des valeurs pour token ou instance. Il n'est donc pas recommandé d'enregistrer un compte local. Tu peux plutôt faire une instanciation directe :

from qiskit_ibm_runtime import QiskitRuntimeService

# Initialize for local testing

service = QiskitRuntimeService(channel="local")

Prochaines étapes​

Recommandations