Uitvoeringscontext en grenzen

5 minuten

Zodra een agent acties kan ondernemen en verbinding kan maken met hulpprogramma's, is de volgende vraag waar en hoe deze acties worden uitgevoerd.

Uitvoeringscontext definieert de grenzen waarbinnen een agent werkt. Dit omvat de opslagplaats waartoe toegang kan worden verkregen, de vertakking waarop wordt gewerkt, de werkstroom die zijn taken uitvoert en de machtigingen die het krijgt.

Zonder een duidelijk gedefinieerde uitvoeringscontext wordt het gedrag van agents onvoorspelbaar en onveilig.

In deze les leert u het volgende:

Wat de uitvoeringscontext betekent in GitHub
Hoe opslagplaats- en vertakkingsbereik grenzen definiëren
Hoe werkstromen de uitvoering isoleren
Hoe toestemmingen controle uitoefenen op agentacties

Wat is uitvoeringscontext?

Uitvoeringscontext is de set beperkingen die bepalen waar een agent werkt en waartoe deze toegang heeft.

In GitHub omvat de uitvoeringscontext:

De opslagplaats waarin de agent werkt
De vertakking waarop de agent is gericht
De werkstroom die bezig is met het uitvoeren van taken
De machtigingen die aan die werkstroom zijn verleend

Deze context bepaalt zowel zichtbaarheid als mogelijkheden.

Bereik van opslagplaats

Agents werken altijd binnen een opslagplaats. Ze kunnen alleen code in die opslagplaats lezen en wijzigen. Ze communiceren met problemen, pull-aanvragen en werkstromen die eraan zijn gekoppeld. Ze hebben geen toegang tot andere opslagplaatsen, tenzij ze expliciet zijn verleend.

Het bereik van de opslagplaats is de eerste grens die het gedrag van agents beperkt.

Hoe het bereik van de opslagplaats wordt geconfigureerd

Voor agents zoals de Copilot cloudagent wordt deze grens expliciet geconfigureerd op opslagplaatsniveau.

Ga als volgt te werk om dit te configureren:

Open uw opslagplaats op GitHub
Klik op Instellingen
In de zijbalk onder Code & automatisering, klik op Copilot
Cloudagent selecteren
De agent voor die opslagplaats inschakelen en configureren
Uw configuratie opslaan

Zodra de agent is geconfigureerd, is de agent beperkt tot die opslagplaats en kan deze daarbuiten niet opereren.

Aangepast toepassingsgebied van een agent binnen een repository

Aangepaste agents werken binnen dezelfde opslagplaatsgrens, maar kunnen hun bereik verder verfijnen via configuratie.

Binnen een aangepast agentbestand (bijvoorbeeld .github/agents/security-reviewer.agent.md), wordt het bereik gedefinieerd met behulp van velden zoals:

applyTo → bepaalt op welke bestanden of mappen de agent zich richt
hulpprogramma's → definieert welke acties de agent kan uitvoeren

Voorbeeld:

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

Een aangepaste agent configureren:

Maak de map .github/agents/ in uw opslagplaats
Een agentbestand toevoegen met de extensie .agent.md
Het bereik definiëren met applyTo en hulpprogramma's
Het bestand doorvoeren en pushen

Hierdoor kan de agent zich alleen richten op specifieke onderdelen van de opslagplaats en werken met beperkte mogelijkheden.

Hoe dit past in de uitvoeringscontext

Het bereik van de opslagplaats definieert waar de agent werkt, terwijl aangepaste agentconfiguratie bepaalt wat de agent binnen die grens kan openen en doen.

Samen vormen ze een gelaagde controle.

Op branches gebaseerde isolatie

Agents werken niet rechtstreeks in de hoofdbranch.

In plaats daarvan:

Een nieuwe vertakking maken op basis van de geselecteerde vertakking
Wijzigingen aanbrengen in de vertakking
Een pull-aanvraag openen die gericht is op een basisbranch

Dit isoleert wijzigingen en zorgt ervoor dat alle wijzigingen worden gecontroleerd voordat ze worden samengevoegd.

Isolatie op basis van vertakkingen is een belangrijk veiligheidsmechanisme.

Een agent configureren om branchespecifieke scope te gebruiken

Als u een Copilot Cloud-agent wilt instellen voor gebruik met een scope gebaseerd op vertakkingen, voert u de volgende stappen uit:

Een basisvertakking selecteren:
- Ga naar de pagina Agents: navigeer naar de pagina Agents in uw GitHub opslagplaats.
Kies de basisbranch: wanneer u taken delegeert aan de Copilot coderingsagent, kunt u een specifieke basisbranch selecteren. Hierdoor kan de agent een nieuwe vertakking maken op basis van uw geselecteerde vertakking in plaats van de standaardbranch (meestal 'main').

Aangepaste agents werken binnen een opslagplaats, maar ze beheren het gedrag van vertakkingen niet rechtstreeks. Het systeem dat de agent uitvoert, bepaalt de scope op basis van vertakkingen.

Hoe werkt het?

Wanneer deze wordt gebruikt met een cloudagent:

Het systeem maakt automatisch een tak
Past wijzigingen toe
Hiermee opent u een pull-aanvraag

Bij gebruik in werkstromen (CI):

De werkstroom bepaalt de vertakking
De agent wordt uitgevoerd binnen die vertakkingscontext

Waar hebben aangepaste agents controle over?

Aangepaste agents definiëren:

Op welke bestanden ze zich richten (applyTo)
Welke acties ze kunnen uitvoeren (hulpprogramma's)
Hoe ze zich gedragen (instructies)

Maar ze definiëren niet:

Vertakking maken
Gedrag van pull-aanvragen
Uitvoeringsisolatie

Bereik op basis van vertakking wordt altijd afgedwongen door de uitvoeringsomgeving, niet de aangepaste agent zelf.

Een agent in staat stellen om autonome acties uit te voeren, waaronder het maken van vertakkingen en pull-aanvragen

Agents kunnen autonome acties uitvoeren binnen een opslagplaats zodra ze zijn ingeschakeld en een taak hebben gekregen.

Steps:

Schakel de agent voor de opslagplaats in.
- Ga naar Instellingen → Copilot → Cloud-agent
- Schakel de agent in, selecteer de opslagplaats
Wijs een taak toe aan de agent.
- Van een probleem, Copilot Chat of de agentinterface
- Voorbeeld: een fout oplossen, een functie implementeren
Hiermee staat u toe dat de agent de taak uitvoert.

De agent doet het volgende:
- Een tak aanmaken
- Codewijzigingen aanbrengen
- Updates doorvoeren en pushen
Controleren en voltooien.

Zodra u tevreden bent met de codewijzigingen en resultaten, activeert u een pull-aanvraag. U kunt wijzigingen in de pull-aanvraag aanvragen of verdergaan en samenvoegen.

De agent werkt autonoom in de opslagplaats door vertakkingen te maken, code te wijzigen en pull-aanvragen te openen, terwijl deze nog steeds binnen een gecontroleerde en controleerbare werkstroom werkt.

Werkstroomgrenzen

Uitvoering vindt plaats binnen werkstromen die worden aangedreven door GitHub Actions. Elke werkstroom definieert welke uitvoering wordt geactiveerd, welke stappen worden uitgevoerd en in welke omgeving de code wordt uitgevoerd. Werkstromen fungeren als beheerde uitvoeringscontainers. Ze zorgen ervoor dat taken worden uitgevoerd in een schone omgeving, dat de uitvoering herhaalbaar is en dat logboeken en resultaten worden vastgelegd. Werkstromen zijn ook hoe agentgedrag wordt uitgevoerd in CI-omgevingen.

Machtigingsgrenzen

Machtigingen definiëren wat een agent kan doen binnen de uitvoeringscontext.

Werkstromen krijgen machtigingen toegewezen via tokens, zoals de GITHUB_TOKEN.

Met deze machtigingen kunt u het volgende toestaan of beperken:

Inhoud van opslagplaats lezen
Code schrijven
Pull-aanvragen maken
Toegang tot geheimen
Werkstromen activeren

Machtigingen moeten altijd expliciet worden gedefinieerd en geminimaliseerd.

Kaders in GitHub agentgedreven werkstromen

GitHub Agentische werkstromen zijn ontworpen met diepgaande verdediging. Belangrijke controles zijn:

Standaard alleen-lezen-tokens, zodat de agent de status van de opslagplaats kan inspecteren zonder deze rechtstreeks te wijzigen
Veilige uitvoer waarmee de agent acties kan voorstellen terwijl een afzonderlijke afgebakende stap bepaalt wat toegelaten wordt.
Nul geheimen in het agentproces, waarbij gevoelige inloggegevens buiten de runtime worden gehouden die door de code-agent wordt gebruikt.
Gesandboxed, gecontaineriseerde uitvoering
Netwerkisolatie en toegestane uitgaande verbindingen
Detectie van bedreigingen die de voorgestelde outputs scant voordat er een schrijfactie wordt toegepast

Dit model helpt de risico's van overprivilegeerde agents, promptinjectie en onbedoelde wijzigingen in de opslagplaats te verminderen.

Waarom grenzen belangrijk zijn

Uitvoeringscontext is wat agentsystemen veilig maakt.

Door het volgende te combineren:

Bereik van opslagplaats
Vertakkingsisolatie
Werkstroomuitvoering
Machtigingsbeheer

GitHub zorgt ervoor dat agents binnen duidelijke, afdwingbare limieten werken.

Dit voorkomt:

Niet-gecontroleerde wijzigingen in productiecode
Toegang tot onbedoelde bronnen
Onveilige of niet-bekeken uitvoering

Hoe agenten worden aangeroepen via werkprocessen

Als u door agents gestuurde taken wilt uitvoeren als onderdeel van CI, roept u deze in een werkstroom aan. In deze installatie wordt de werkstroom de uitvoeringsgrens en wordt de agent uitgevoerd binnen de runner met behulp van gedefinieerde stappen en machtigingen.

Steps:

Maak of open een werkstroombestand in uw opslagplaats: .github/workflows/agent-task.yml
Definiëren wanneer de werkstroom moet worden uitgevoerd:
```
on:
 workflow_dispatch: 
schedule: - cron: '0 9 * * *' 
```
U kunt ook gebeurtenissen zoals pushen of pull_request gebruiken, afhankelijk van uw use-case.
Werkstroomtoestemmingen instellen
```
permissions: 
    contents: read
```
Pas machtigingen aan op basis van wat de werkstroom moet doen.

Definieer een taak en runner:

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

Bekijk de opslagplaats:
```
uses: actions/checkout@v4
```

Node.js instellen:

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

Verificatie opgeven:

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

Voer de agenttaak uit:

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

Een aangepaste agent gebruiken:

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

De werkstroom wordt het beheerde uitvoeringspad voor de agent. De taak wordt uitgevoerd op een gedefinieerde runner, met een gedefinieerde trigger, binnen de context van een gedefinieerde opslagplaats en met alleen de machtigingen die aan die werkstroom zijn verleend.

Uitvoering van vertakkingsbereik en werkstroom

Werkstromen worden uitgevoerd op een specifieke tak.

Aangezien agents wijzigingen aanbrengen op een branch:

De uitvoering van de werkstroom is beperkt tot die vertakking
Wijzigingen worden geïsoleerd van de standaardbranch
Validatie vindt plaats voordat u samenvoegt

Dit zorgt ervoor dat agentactiviteit binnen een beheerd uitvoeringsbereik blijft.

Belangrijkste bevinding

Uitvoeringscontext definieert waar agents werken. Grenzen zoals opslagplaatsbereik, vertakkingsisolatie, werkstromen en machtigingen zorgen ervoor dat agentacties beheerd, voorspelbaar en veilig blijven.

Vervolgens leert u hoe u veilige uitvoeringspaden ontwerpt, waaronder nieuwe pogingen, terugdraaiacties en escalatiemechanismen.

Feedback

Is deze pagina nuttig?