Server-zu-Server-Authentifizierung

GitHub Actions

Erteilen Sie für Workflows in einem organisationseigenen Repository die integrierte Tokenberechtigung, um Copilot Anforderungen zu stellen:

permissions:
  contents: read
  copilot-requests: write

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

Die zulassungsfähige Verwendung von Copilot CLI, die der Organisationsrichtlinie in Rechnung gestellt wird, muss aktiviert sein. Dieser Ansatz benötigt keinen GitHub App- oder gespeicherten Authentifizierungsschlüssel. Ausführliche Informationen findest du unter Verwenden von Copilot CLI in GitHub Actions mit GITHUB_TOKEN.

Andere Dienstleistungen und CI-Systeme

Für Dienste außerhalb GitHub Actions:

1. Erstellen Sie eine GitHub App mit der Copilot Anforderungs-Repositoryberechtigung auf Lese-& Schreibzugriff.

2. Installieren Sie sie in der Organisation, die in Rechnung gestellt werden soll. Die aktuelle Copilot Berechtigungsprüfung erfordert Zugriff auf alle Repositorys.

3. Generieren eines Installationszugriffstokens für eine GitHub App mit einer Repository-ID und der Copilot Berechtigung:

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

4. Übergeben Sie das resultierende ghs_ Token an die Laufzeit als COPILOT_GITHUB_TOKEN.

Die Organisation muss für Copilot Anforderungen von GitHub App-Installationen aktiviert sein. Installationstoken laufen nach einer Stunde ab.

Konfigurieren der Runtime

In den folgenden Beispielen wird davon ausgegangen, dass das geprägte Token in INSTALLATION_TOKENist. Sie übergeben es nur an die untergeordnete Laufzeit und deaktivieren Fallback auf gespeicherte Benutzeranmeldeinformationen.

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.
}

Legen Sie für prozessinterne FFI in der Hostumgebung vor dem Laden der Laufzeit fest COPILOT_GITHUB_TOKEN . Optionen pro Clientumgebung werden nicht unterstützt. Legen Sie ihn für einen vorhandenen Laufzeit-URI für diesen Laufzeitprozess fest.

Aktualisierungs-Token

Stellen Sie ein neues Installationstoken vor Ablauf des aktuellen Tokens vor. Starten Sie für einen untergeordneten Prozess den SDK-Client mit der neuen Umgebung neu. Starten Sie für eine in-Process- oder vorhandene Laufzeit die Hostlaufzeit mit dem neuen Token neu.

Billing

Die Verwendung wird dem Konto zugeordnet und in Rechnung gestellt, das die GitHub App-Installation besitzt. Verwenden Sie eine Organisationsinstallation für die Abrechnung der Organisation; Verwendung von Benutzerkontoinstallationsattributen für diesen Benutzer.

Troubleshooting

Weiterführende Lektüre

• Authentication: andere Authentifizierungsmethoden und Priorität
• Generieren eines Installationszugriffstokens für eine GitHub App: GitHub App-Tokenerstellung