Autenticación de servidor a servidor

Acciones de GitHub

En el caso de los flujos de trabajo de un repositorio propiedad de la organización, conceda el permiso de token integrado para realizar solicitudes Copilot:

permissions:
  contents: read
  copilot-requests: write

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

La directiva de organización Permitir el uso de Copilot CLI facturada a la directiva de organización debe estar habilitada. Este enfoque no necesita ningún secreto de autenticación almacenado ni GitHub aplicación. Para obtener más información, consulte Uso de la CLI de Copilot en Acciones de GitHub con GITHUB_TOKEN.

Otros servicios y sistemas de CI

Para servicios fuera de Acciones de GitHub:

1. Cree una aplicación GitHub con el Copilot permiso de repositorio Solicitudes establecido en Lectura y escritura.

2. Instálelo en la organización que se debe facturar. La comprobación de permisos de Copilot actual requiere acceso a todos los repositorios.

3. Generación de un token de acceso de instalación para una aplicación de GitHub con un identificador de repositorio y el permiso Copilot:

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

4. Pase el token resultante ghs_ al entorno de ejecución como COPILOT_GITHUB_TOKEN.

La organización debe estar habilitada para Copilot solicitudes de GitHub instalaciones de aplicaciones. Los tokens de instalación expiran después de una hora.

Configuración del entorno de ejecución

En los ejemplos siguientes se supone que el token minted está en INSTALLATION_TOKEN. Solo lo pasan al entorno de ejecución secundario y deshabilitan la reserva a las credenciales de usuario almacenadas.

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

Para FFI en proceso, establezca COPILOT_GITHUB_TOKEN en el entorno de host antes de cargar el entorno de ejecución; no se admiten las opciones de entorno por cliente. Para un URI en tiempo de ejecución existente, establézcalo en ese proceso en tiempo de ejecución.

Tokens de refresco

Emita un nuevo token de instalación antes de que expire el token actual. Para un proceso secundario, reinicie el cliente del SDK con el nuevo entorno. Para un entorno de ejecución en proceso o existente, reinicie el entorno de ejecución del host con el nuevo token.

Billing

El uso se atribuye y factura a la cuenta que posee la instalación de la aplicación GitHub. Usar una instalación de la organización para la facturación de la organización; un uso de atributos de instalación de cuenta de usuario para ese usuario.

Troubleshooting

Lectura adicional

• Autenticación: otros métodos de autenticación y prioridad
• Generación de un token de acceso de instalación para una aplicación de GitHub: creación de tokens de aplicación de GitHub