Körningskontext och gränser

  • 5 minuter

När en agent kan vidta åtgärder och ansluta till verktyg är nästa fråga var och hur dessa åtgärder körs.

Exekveringskontext definierar gränserna inom vilka en agent verkar. Detta inkluderar den lagringsplats som den kan komma åt, den gren som den fungerar på, arbetsflödet som kör dess uppgifter och de behörigheter som den beviljas.

Utan en tydligt definierad körningskontext blir agentbeteendet oförutsägbart och osäkert.

I den här lektionen får du lära dig:

  • Vad körningskontext innebär i GitHub
  • Hur lagringsplats och grenomfång definierar gränser
  • Hur arbetsflöden isolerar exekvering
  • Så här framtvingar behörigheter kontroll över agentåtgärder

Vad är körningskontext?

Körningskontext är den uppsättning begränsningar som definierar var en agent fungerar och vad den kan komma åt.

I GitHub omfattar körningskontexten:

  • Lagringsplatsen som agenten arbetar i
  • Den gren som agenten riktar in sig på
  • Arbetsflödet som kör uppgifter
  • Behörigheterna som beviljats till arbetsflödet

Den här kontexten avgör både synlighet och kapacitet.

Lagringsplatsomfång

Agenter fungerar alltid inom ett repository. De kan bara läsa och ändra kod på den lagringsplatsen. De interagerar med ärenden, pull-requester och arbetsflöden som är associerade med det. De har inte åtkomst till andra lagringsplatser om de inte uttryckligen beviljas.

Lagringsplatsens omfång är den första gränsen som begränsar agentbeteendet.

Så här konfigureras lagringsplatsens omfång

För agenter som Copilot molnagent konfigureras den här gränsen uttryckligen på lagringsplatsnivå.

Så här konfigurerar du detta:

  1. Öppna lagringsplatsen på GitHub
  2. Klicka på Inställningar
  3. I sidofältet, under Kod & automation klickar du på Copilot
  4. Välj Molnagent
  5. Aktivera och konfigurera agenten för lagringsplatsen
  6. Spara konfigurationen

När agenten har konfigurerats är den begränsad till lagringsplatsen och kan inte användas utanför den.

Anpassat agentomfång på en lagringsplats

Anpassade agenter fungerar inom samma gräns i lagringsplatsen men kan ytterligare förfina sitt omfång genom konfiguration.

I en anpassad agentfil (till exempel .github/agents/security-reviewer.agent.md) definieras omfånget med hjälp av fält som:

  • applyTo → gränser för vilka filer eller kataloger agenten fokuserar på
  • verktyg → definierar vilka åtgärder agenten kan utföra

Exempel:

applyTo:
    - '**/*.js'
    - 'src/auth/**' tools:
    - read_file
    - search_files

Så här konfigurerar du en anpassad agent:

  1. Skapa katalogen .github/agents/i lagringsplatsen
  2. Lägg till en agentfil med tillägget .agent.md
  3. Definiera dess omfång med applyTo och verktyg
  4. Committa och pusha filen

Detta gör att agenten endast kan fokusera på specifika delar av lagringsplatsen och arbeta med begränsade funktioner.

Så här passar detta in i körningskontexten

Lagringsplatsens omfång definierar var agenten fungerar, medan konfiguration av anpassad agent definierar vad agenten kan komma åt och göra inom den gränsen.

Tillsammans skapar de ett flerskiktat system för kontroll.

Grenbaserad isolering

Agenter arbetar inte direkt på huvudgrenen.

I stället:

  • Skapa en ny gren från den gren du valde
  • Gör ändringar i den grenen
  • Öppna en pull-begäran som riktar sig mot en basgren

Detta isolerar ändringar och säkerställer att alla ändringar genomgår granskning innan de sammanfogas.

Grenbaserad isolering är en viktig säkerhetsmekanism.

Konfigurera en agent för att använda grenbaserat omfång

Följ dessa steg för att konfigurera en Copilot Cloud-agent som ska fungera med ett grenbaserat omfång:

  1. Välja en basgren:
    • Gå till agentersidan: Navigera till agentersidan i ditt GitHub-arkiv.
  2. Välj basgren: När du delegerar uppgifter till Copilot kodningsagenten kan du välja en specifik basgren. Detta gör att agenten kan skapa en ny gren baserat på din valda gren i stället för standardgrenen (vanligtvis "main").

Anpassade agenter fungerar på en lagringsplats, men de styr inte grenbeteendet direkt. Grenbaserat omfång bestäms av systemet som kör agenten.

Så här fungerar det

När den används med en molnagent:

  • Systemet skapar automatiskt en gren
  • Tillämpar ändringar
  • Öppnar en pull-förfrågan

När det används i arbetsflöden (CI):

  • Arbetsflödet avgör grenen
  • Agenten körs inom den grenkontexten

Vad anpassade agenter styr

Anpassade agenter definierar:

  • Vilka filer de fokuserar på (applyTo)
  • Vilka åtgärder de kan utföra (verktyg)
  • Så här fungerar de (instruktioner)

Men de definierar inte:

  • Skapa gren
  • Beteende för pull-begäranden
  • Körningsisolering

Grenbaserad räckvidd tillämpas alltid av körningskontexten, inte av den egna anpassade agenten.

Aktivera en agent för att utföra autonoma åtgärder, inklusive att skapa grenar och pull-begäranden

Agenter kan utföra autonoma åtgärder på en lagringsplats när de har aktiverats och fått en uppgift.

Steps:

  1. Aktivera agenten för lagringsplatsen.

    • Gå till Inställningar → Copilot → Molnagent
    • Aktivera agenten, välj lagringsplatsen

  2. Tilldela en uppgift till agenten.

    • Från ett ärende, Copilot Chat eller agentgränssnittet
    • Exempel: åtgärda en bugg, implementera en funktion

  3. Tillåt agenten att utföra uppgiften.

    Agenten kommer att:

    • Skapa en gren
    • Att göra kodändringar
    • Checka in och skicka uppdateringar

  4. Granska och slutför.

    När du är nöjd med kodändringarna och resultaten utlöser du en pull-begäran. Du kan begära ändringar i pull-begäran eller gå vidare och sammanfoga.

Agenten fungerar självständigt på lagringsplatsen genom att skapa grenar, ändra kod och öppna pull-begäranden, samtidigt som den körs inom ett kontrollerat och granskningsbart arbetsflöde.

Arbetsflödesgränser

Exekvering sker i arbetsflöden som drivs av GitHub Actions. Varje arbetsflöde definierar vad som utlöser körning, vilka steg som utförs och vilken miljö koden körs i. Arbetsflöden fungerar som kontrollerade exekveringsbehållare. De ser till att aktiviteter körs i en ren miljö, att körningen kan upprepas och att loggar och resultat registreras. Arbetsflöden är också hur agentbeteendet körs i CI-miljöer.

Behörighetsgränser

Åtkomsträttigheter definierar vad en agent kan göra i sin exekveringskontext.

Arbetsflöden tilldelas behörigheter via token, till exempel GITHUB_TOKEN.

Dessa behörigheter kan tillåta eller begränsa:

  • Läsa innehållet i lagringsplatsen
  • Skriva kod
  • Skapa pull-begäranden
  • Åtkomst till hemligheter
  • Utlösa arbetsflöden

Behörigheter bör alltid definieras och minimeras uttryckligen.

Skyddsräcken i GitHub agentiska arbetsflöden

GitHub Agentic Workflows är utformade med försvar i flera lager. Viktiga kontroller är:

  • Skrivskyddade token som standard så att agenten kan inspektera lagringsplatsens tillstånd utan att ändra den direkt
  • Säkra utdata som gör att agenten kan föreslå åtgärder medan ett separat gated-steg avgör vad som är tillåtet
  • Inga hemligheter i agentprocessen, som håller känsliga autentiseringsuppgifter borta från runtime-miljön som används av kodagenten.
  • Körning i sandlåda och containeriserad miljö
  • Nätverksisolering och tillåten utgående åtkomst
  • Hotidentifiering som söker igenom föreslagna utdata innan någon skrivåtgärd tillämpas

Den här modellen hjälper till att minska riskerna med överprivilegierade agenter, snabbinmatning och oavsiktliga ändringar av lagringsplatsen.

Varför gränser spelar roll

Körningskontext är det som gör agentsystem säkra.

Genom att kombinera:

  • Lagringsplatsomfång
  • Grenisolering
  • Arbetsflödesexekvering
  • Behörighetskontroll

GitHub ser till att agenter fungerar inom tydliga och verkställbara gränser.

Detta förhindrar:

  • Okontrollerade ändringar i produktionskoden
  • Åtkomst till oavsiktliga resurser
  • Osäker eller ej granskad exekvering

Hur agenter anropas via arbetsflöden

Om du vill köra agentdrivna uppgifter som en del av CI anropar du dem i ett arbetsflöde. I den här konfigurationen blir arbetsflödet exekveringsgränsen och agenten körs inom exekveraren med definierade steg och behörigheter.

Steps:

  1. Skapa eller öppna en arbetsflödesfil på lagringsplatsen: .github/workflows/agent-task.yml

  2. Definiera när arbetsflödet ska köras:

    on:
 workflow_dispatch: 
schedule: - cron: '0 9 * * *'

    Du kan också använda händelser som push eller pull request beroende på ditt användningsfall.

  3. Ange arbetsflödesbehörigheter:

    permissions: 
    contents: read

    Justera behörigheter baserat på vad arbetsflödet behöver göra.

  4. Definiera ett jobb och en löpare:

    jobs: 
	agent-task: 
		runs-on: ubuntu-latest

  5. Kolla in lagringsplatsen:

    uses: actions/checkout@v4

  6. Konfigurera Node.js:

    uses: actions/setup-node@v4 
with: node-version: '18'

  7. Ange autentisering:

    env: COPILOT_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  8. Kör agentuppgiften:

    run: | npx @github/copilot-cli 
-p "Summarize recent changes in this repository" 
--no-ask-user (Optional)

  9. Använd en anpassad agent:

    run: | npx @github/copilot-cli 
--agent security-reviewer 
-p "Review this code for vulnerabilities" 
--no-ask-user

Arbetsflödet fungerar som en kontrollerad körningsväg för agenten. Uppgiften körs på en definierad löpare, med en definierad utlösare, i en definierad lagringsplatskontext och med endast de behörigheter som beviljats arbetsflödet.

Grenomfång och arbetsflödeskörning

Arbetsflöden körs mot en specifik gren.

Eftersom agenter gör ändringar på en branch:

  • Arbetsflödeskörningen är begränsad till den specifika grenen
  • Ändringar isoleras från standardgrenen
  • Validering sker före sammanslagning

Detta säkerställer att agentaktiviteten förblir inom ett kontrollerat exekveringsomfång.

Viktig insikt

Körningskontext definierar var agenter fungerar. Gränser som lagringsplatsomfång, grenisolering, arbetsflöden och behörigheter säkerställer att agentåtgärder förblir kontrollerade, förutsägbara och säkra.

Därefter får du lära dig hur du utformar säkra exekveringsvägar, inklusive återförsök, återgångar och eskaleringsmekanismer.