Authentification serveur à serveur

GitHub Actions

Pour les flux de travail d’un référentiel appartenant à l’organisation, accordez l’autorisation de jeton intégré pour effectuer des requêtes Copilot :

permissions:
  contents: read
  copilot-requests: write

jobs:
  copilot:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - run: your-application
        env:
          GITHUB_TOKEN: $

L'option Autoriser l'utilisation d'Copilot CLI facturée à la stratégie d'organisation doit être activée. Cette approche n’a pas besoin d’une application GitHub ou d’un secret d’authentification stocké. Pour plus d’informations, consultez Utilisation de l’interface CLI Copilot dans GitHub Actions avec GITHUB_TOKEN.

Autres services et systèmes CI

Pour les services en dehors de GitHub Actions :

1. Créez une application GitHub avec l’autorisation Copilot Demander l’autorisation de dépôt en lecture et écriture.

2. Installez-le sur l’organisation qui doit être facturée. La vérification des autorisations Copilot actuelle nécessite l’accès à tous les référentiels.

3. Génération d’un jeton d’accès d’installation pour une application GitHub avec un ID de référentiel et l’autorisation Copilot :

   {
     "repository_ids": [123456789],
     "permissions": {
       "copilot_requests": "write"
     }
   }
   

4. Transmettez le jeton résultant ghs_ au runtime en tant que COPILOT_GITHUB_TOKEN.

L’organisation doit être activée pour Copilot demandes des installations d’applications GitHub. Les jetons d’installation expirent après une heure.

Configurer le runtime

Les exemples suivants supposent que le jeton frappé est en INSTALLATION_TOKEN. Ils le transmettent uniquement au runtime enfant et désactivent la secours aux informations d’identification utilisateur stockées.

import { CopilotClient, RuntimeConnection } from "@github/copilot-sdk";

const token = process.env.INSTALLATION_TOKEN;
if (!token) throw new Error("INSTALLATION_TOKEN is required");

const client = new CopilotClient({
    connection: RuntimeConnection.forStdio(),
    env: {
        ...process.env,
        COPILOT_GITHUB_TOKEN: token,
    },
    useLoggedInUser: false,
});

import os

from copilot import CopilotClient, RuntimeConnection

client = CopilotClient(
    connection=RuntimeConnection.for_stdio(),
    env={**os.environ, "COPILOT_GITHUB_TOKEN": os.environ["INSTALLATION_TOKEN"]},
    use_logged_in_user=False,
)

package main

import (
    "log"
    "os"

    copilot "github.com/github/copilot-sdk/go"
)

func main() {
    token, ok := os.LookupEnv("INSTALLATION_TOKEN")
    if !ok {
        log.Fatal("INSTALLATION_TOKEN is required")
    }
    client := copilot.NewClient(&copilot.ClientOptions{
        Connection:      copilot.StdioConnection{},
        Env:             append(os.Environ(), "COPILOT_GITHUB_TOKEN="+token),
        UseLoggedInUser: copilot.Bool(false),
    })
    _ = client
}

use github_copilot_sdk::{ClientOptions, Transport};

fn main() {
    let token = std::env::var("INSTALLATION_TOKEN").expect("INSTALLATION_TOKEN is required");
    let options = ClientOptions::new()
        .with_transport(Transport::Stdio)
        .with_env([("COPILOT_GITHUB_TOKEN", token)])
        .with_use_logged_in_user(false);
    drop(options);
}

using System.Collections;
using GitHub.Copilot;

var token = Environment.GetEnvironmentVariable("INSTALLATION_TOKEN")
    ?? throw new InvalidOperationException("INSTALLATION_TOKEN is required");
var environment = Environment.GetEnvironmentVariables()
    .Cast<DictionaryEntry>()
    .ToDictionary(entry => (string)entry.Key, entry => entry.Value?.ToString() ?? "");
environment["COPILOT_GITHUB_TOKEN"] = token;

await using var client = new CopilotClient(new CopilotClientOptions
{
    Connection = RuntimeConnection.ForStdio(),
    Environment = environment,
    UseLoggedInUser = false,
});

import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.CopilotClientOptions;
import java.util.HashMap;
import java.util.Objects;

var environment = new HashMap<>(System.getenv());
var token = Objects.requireNonNull(
    System.getenv("INSTALLATION_TOKEN"), "INSTALLATION_TOKEN is required");
environment.put("COPILOT_GITHUB_TOKEN", token);

try (var client = new CopilotClient(new CopilotClientOptions()
        .setEnvironment(environment)
        .setUseLoggedInUser(false))) {
    // Use the client.
}

Pour la FFI in-process, définie COPILOT_GITHUB_TOKEN dans l’environnement hôte avant de charger le runtime ; les options d’environnement par client ne sont pas prises en charge. Pour un URI d’exécution existant, définissez-le sur ce processus d’exécution.

Jetons d’actualisation

Frappez un nouveau jeton d’installation avant l’expiration du jeton actuel. Pour un processus enfant, redémarrez le client sdk avec le nouvel environnement. Pour un runtime in-process ou existant, redémarrez le runtime hôte avec le nouveau jeton.

Billing

L’utilisation est attribuée et facturée au compte propriétaire de l’installation de l’application GitHub. Utiliser une installation d’organisation pour la facturation de l’organisation ; une utilisation des attributs d’installation de compte d’utilisateur pour cet utilisateur.

Résolution des problèmes

Lectures complémentaires

• Authentification : autres méthodes d’authentification et priorité
• Génération d’un jeton d’accès d’installation pour une application GitHub : création de jetons d’application GitHub