Connectez la CLI de GitHub Copilot à un point d’inférence Windows Server

GitHub Copilot CLI est un agent de codage IA qui peut envoyer des requêtes de modèles d’un client Windows supporté vers un point d’inférence compatible OpenAI hébergé sur Windows Server. Cette configuration vous permet d’utiliser un modèle hébergé par l’organisation depuis votre terminal, tandis que Windows Server centralise l’hébergement et le calcul du modèle.

Cet article vous montre comment configurer la connexion client et vérifier que le modèle configuré répond. Il ne déploie pas et ne sécurise pas le service d’inférence.

Prerequisites

Un ordinateur client qui exécute une version Windows prise en charge par la ligne de commande GitHub Copilot, avec :
- PowerShell 6 ou plus récent.
- Windows Gestionnaire de package (WinGet).
Un abonnement actif GitHub Copilot. Si une organisation ou une entreprise fournit votre abonnement, son administrateur doit autoriser la CLI de GitHub Copilot.
Un répertoire de travail fiable à partir duquel démarrer la CLI de GitHub Copilot.
Un point de terminaison compatible OpenAI existant sur Windows Server qui :
- Est accessible depuis l’ordinateur client.
- Nécessite l’authentification. Cette procédure s’applique aux connexions Windows Server distantes. Réservez les points de terminaison sans authentification pour les scénarios de boucle uniquement en dehors de cette procédure.
- Écoute uniquement sur l’interface réseau serveur prévue, permet les connexions entrantes uniquement depuis des ordinateurs clients autorisés ou des sous-réseaux, et n’accepte pas les connexions directes depuis l’internet public.
- Prend en charge le streaming et l’appel d’outils ou de fonctions. La compatibilité OpenAI seule ne garantit pas le support de toutes les capacités CLI de GitHub Copilot. Vérifiez les capacités du point de terminaison et des modèles sélectionnés avec l’opérateur du point de terminaison.
Une connexion réseau Windows-client-à-Windows-Server qui possède :
- Un nom DNS pour le point d’inférence Windows Server qui se résout depuis l’ordinateur client.
- Une route réseau et des règles de pare-feu qui permettent uniquement aux clients ou aux sous-réseaux autorisés de se connecter au port du point de terminaison.
- Un certificat HTTPS auquel le client a confiance et dont le nom de sujet ou le nom alternatif correspond au nom DNS du point de terminaison.
L’URL de base du point de terminaison, comme https://inference.contoso.com/v1.
Le type d’identifiant et d’authentification du point de terminaison spécifié par l’opérateur du point de terminaison.

Installer la CLI de GitHub Copilot

Ouvrez PowerShell.
Installez le paquet CLI stable GitHub Copilot :
```
winget install GitHub.Copilot
```
Confirmez que l’installation a réussi :
```
copilot --version
```
La commande renvoie la version CLI installée de GitHub Copilot.

Obtenez un identifiant de modèle depuis le point d’inférence Windows Server

Définissez l’URL de base fournie par l’opérateur de point de terminaison :
```
$BaseUrl = 'https://inference.contoso.com/v1'
```
Entrez la clé API ou le jeton porteur que l’opérateur de point d’extrémité spécifie. Utilisez une certification de courte durée et de moindre privilège. Lorsque votre organisation fournit une commande de stockage secret approuvée, utilisez-la pour récupérer la certification au lieu de la saisir directement. La commande suivante convertit la SecureString valeur en valeur en texte $endpointCredential clair, qui reste en mémoire pour cette session PowerShell.
```
$secureEndpointCredential = Read-Host 'Enter the endpoint credential' -AsSecureString
$endpointCredential = [System.Net.NetworkCredential]::new('', $secureEndpointCredential).Password
```
Envoyez une GET demande à $BaseUrl/models. Incluez $endpointCredential dans un en-tête Authorization: Bearer, et lisez chaque identifiant de modèle à partir du tableau data de la réponse :
```
$requestParameters = @{
   Uri = "$BaseUrl/models"
   Method = 'Get'
}

try {
   $requestParameters.Headers = @{ Authorization = "Bearer $endpointCredential" }
   $models = Invoke-RestMethod @requestParameters
   $models.data | Select-Object -ExpandProperty id
}
finally {
   $requestParameters.Headers = $null
}
```
La commande renvoie un ou plusieurs identifiants de modèle. Copiez l’ID exact d’un modèle qui prend en charge le streaming et l’appel d’outils ou de fonctions.

Configurez le fournisseur et le modèle CLI de GitHub Copilot

Définissez $BaseUrl à l’URL de base du point de terminaison Windows Server et $endpointCredential à sa clé API ou jeton porteur. Dans la même session PowerShell, définissez le type de fournisseur, l’URL de base du point de terminaison et l’ID exact du modèle. Remplacez-le <MODEL_ID> par un ID que le point de terminaison Windows Server renvoie.
```
$env:COPILOT_PROVIDER_TYPE = 'openai'
$env:COPILOT_PROVIDER_BASE_URL = $BaseUrl
$env:COPILOT_MODEL = '<MODEL_ID>'
```
Le openai type de fournisseur prend en charge les terminaux compatibles OpenAI, y compris vLLM.

Effacez toutes les variables d’authentification du fournisseur que la session PowerShell actuelle a héritées :

Remove-Item Env:COPILOT_PROVIDER_API_KEY, Env:COPILOT_PROVIDER_BEARER_TOKEN, Env:COPILOT_PROVIDER_API_KEY_COMMAND -ErrorAction SilentlyContinue

Configurez la méthode d’authentification spécifiée par l’opérateur de terminaison :
- Pour l’authentification standard par clé API OpenAI, utilisez une commande de stockage secret approuvée par l’organisation dès qu’une commande est disponible :
```
$env:COPILOT_PROVIDER_API_KEY_COMMAND = '<APPROVED_SECRET_STORE_COMMAND>'
```
  La commande doit récupérer la validation depuis un magasin secret approuvé, ne produire que la validation, et ne pas la journaliser ni la faire persister. COPILOT_PROVIDER_API_KEY_COMMAND est prioritaire par rapport à COPILOT_PROVIDER_API_KEY.
- Si aucune commande secret-store approuvée n’est disponible, définissez directement la clé API comme solution de secours éphémère pour la session PowerShell actuelle :
```
$env:COPILOT_PROVIDER_API_KEY = $endpointCredential
```
- Pour l’authentification du jeton porteur, définissez le jeton porteur :
```
$env:COPILOT_PROVIDER_BEARER_TOKEN = $endpointCredential
```
Important

Ne mettez pas de clés API dans les scripts, le contrôle de version ou les exemples de commandes. copilot et tout processus qu’il démarre hérite des variables de l’environnement d’authentification des fournisseurs. Utilisez des identifiants de courte durée et de privilèges minimes, et supprimez les variables après avoir quitté la ligne de code de GitHub Copilot.
Examinez les variables fournisseurs prises en charge dans votre version installée :
```
copilot help providers
```

Démarrez et vérifiez la CLI de GitHub Copilot

Changez vers un répertoire dont vous avez confiance dans les fichiers :
```
Set-Location 'C:\path\to\trusted-project'
```

Important

Si vous vous arrêtez avant de commencer copilot, ou si une commande antérieure échoue, supprimez les variables d’authentification du fournisseur, effacez les en-têtes de requête et supprimez l’identifiant sécurisé avant de fermer PowerShell :

if ($requestParameters) {
   $requestParameters.Headers = $null
}

Remove-Item Env:COPILOT_PROVIDER_API_KEY, Env:COPILOT_PROVIDER_BEARER_TOKEN, Env:COPILOT_PROVIDER_API_KEY_COMMAND -ErrorAction SilentlyContinue

if ($secureEndpointCredential) {
   $secureEndpointCredential.Dispose()
}

Fermez la session PowerShell une fois le nettoyage terminé. La chaîne de texte $endpointCredential clair immuable reste en mémoire jusqu’à la fin du processus.

Lance la CLI de GitHub Copilot et exécute les étapes de vérification dans un try bloc afin que PowerShell supprime les variables d’authentification des fournisseurs et élimine la SecureString valeur lorsque vous quittez ou que la commande échoue :

try {
   copilot
}
finally {
   if ($requestParameters) {
      $requestParameters.Headers = $null
   }

   Remove-Item Env:COPILOT_PROVIDER_API_KEY, Env:COPILOT_PROVIDER_BEARER_TOKEN, Env:COPILOT_PROVIDER_API_KEY_COMMAND -ErrorAction SilentlyContinue

   if ($secureEndpointCredential) {
      $secureEndpointCredential.Dispose()
   }
}

Confirmez l’invite trusted-directory. Faites confiance au répertoire pour les sessions futures uniquement si vous contrôlez son contenu et attendez de ce qu’il reste digne de confiance.
Si la CLI de GitHub Copilot vous invite, entrez /login et suivez les instructions pour vous authentifier sur GitHub. L’authentification GitHub est distincte de la clé API qui authentifie le point d’inférence.
Saisissez cette invite de test :
```
Reply with exactly: Local inference test succeeded
```
Le modèle configuré sur le point de terminaison Windows Server affiche Local inference test succeeded sans erreur de fournisseur, d’authentification ou de compatibilité de modèle. Après avoir quitté la CLI de GitHub Copilot, PowerShell exécute le bloc finally. PowerShell ne peut pas effacer de manière fiable la chaîne de texte $endpointCredential clair immuable de la mémoire, donc fermez la session PowerShell après la fin de la commande pour libérer la mémoire du processus.

Dépanner les connexions CLI de GitHub Copilot vers un point d’inférence Windows Server

Problème	Que vérifier
La requête du modèle n’atteint pas le point de terminaison	Vérifiez l’URL de base du point de terminaison, la résolution DNS, le port, la route réseau, l’état du service et la confiance du certificat TLS. L’URL de base doit inclure le préfixe API fourni par l’opérateur de terminaison, tel que `/v1`.
Les modèles demandent des retours `401` ou `403`	Vérifiez que la qualification est valide. Pour l’authentification par clé API, privilégiez l’utilisation de `COPILOT_PROVIDER_API_KEY_COMMAND` avec une commande approuvée de stockage des secrets. Utilisez `COPILOT_PROVIDER_API_KEY` uniquement comme solution de secours de courte durée. Pour l’authentification par jeton porteur, on définit `COPILOT_PROVIDER_BEARER_TOKEN`, comme le spécifie l’opérateur de point d’extrémité.
La CLI de GitHub Copilot utilise un autre fournisseur ou modèle	Définissez le type de fournisseur, l’URL de base, le modèle et la variable d’authentification sélectionnée dans la même session PowerShell qui démarre `copilot`. Utilisez l’ID de modèle exact que le point de terminaison renvoie. Vérifiez `$HOME\.copilot\providers.json`également ; les déclarations de fournisseur ou de modèle de ce fichier ont la priorité sur les `COPILOT_PROVIDER_*` variables.
La ligne de commande GitHub Copilot ne trouve pas le modèle	Interrogez de nouveau `$BaseUrl/models` et comparez la valeur `COPILOT_MODEL` à la valeur `id` que le point de terminaison renvoie, y compris les majuscules et la ponctuation.
L’invite échoue après que le point de terminaison a accepté la requête	Confirmez que le modèle et le terminau supportent à la fois le streaming et l’appel d’outils ou de fonctions. Examinez les journaux du point de terminaison pour vérifier s’il existe un champ de requête, un schéma d’outil, une limite de contexte ou un format de réponse non pris en charge.

Commentaires

Est-ce que cette page vous a été utile?

Last updated on 2026-09-28