Votre agent de revue peut maintenant exécuter Shell, mais il utilise encore un Runner relié à vos ressources internes.

La solution la plus rapide est de conserver le Runner GitHub hébergé pour les dépôts peu sensibles, de passer à un Runner hébergé renforcé lorsque le problème est la capacité, et de réserver ARC à l’isolement des dépôts ayant réellement besoin d’un réseau interne. Pour iOS et macOS, séparez toujours la revue Copilot de la construction Xcode et de la signature sur un Mac indépendant.

Cet article s’adresse aux responsables de développement qui doivent classer leurs dépôts, aux équipes de plateforme et de sécurité qui contrôlent Shell, les sorties réseau, MCP et les identifiants, ainsi qu’aux équipes iOS et macOS qui doivent prouver qu’un même commit a bien été construit dans un environnement Apple réel.

> **Attention :** l’exécution réussie d’une commande ne constitue ni une approbation de Pull Request, ni une preuve de sécurité de la chaîne de dépendances. La revue, les tests déterministes et la fusion restent trois décisions distinctes.

Le changement à traiter comme un problème d’environnement

GitHub a confirmé que Copilot code review repose désormais sur une architecture agentique capable d’utiliser des outils Shell pour lancer des constructions, des tests et des scripts ciblés. L’exécution par défaut se fait dans un environnement Actions temporaire hébergé par GitHub, et la configuration peut également utiliser des Runner hébergés renforcés ou un Runner Ubuntu x64 autohébergé géré par Actions Runner Controller, appelé ARC ([annonce GitHub sur l’architecture agentique de la revue de code](https://github.blog/changelog/2026-03-05-copilot-code-review-now-runs-on-an-agentic-architecture/) et [documentation de configuration des Runner pour Copilot code review](https://docs.github.com/en/copilot/how-tos/copilot-on-github/set-up-copilot/configure-runners)).

Cela ne signifie pas que chaque dépôt doit recevoir un Runner autogéré. Trois limites doivent être séparées avant toute décision :

- **La capacité :** un dépôt volumineux peut attendre à cause du processeur, de la mémoire, du disque, de l’installation des dépendances ou de la durée d’exécution. Un Runner renforcé traite ce type de contrainte, mais ne crée pas automatiquement une frontière de sécurité. - **Le réseau :** un Runner qui peut joindre des paquets privés, un registre interne ou un service de test possède une capacité d’accès que l’environnement temporaire n’a pas nécessairement. Cette ouverture doit être intentionnelle, limitée et journalisée. - **Les secrets et la chaîne logicielle :** une commande Shell peut lire des fichiers générés, appeler un script d’initialisation ou exploiter une dépendance compromise. Un pare-feu d’agent réduit certains chemins d’exfiltration, mais ne remplace ni la segmentation du Runner ni la gestion des identifiants.

Les consommations doivent également rester distinctes. Pour un dépôt privé, les minutes GitHub Actions et la consommation liée à Copilot ne constituent pas une seule enveloppe : vérifiez les règles d’utilisation des Actions dans la [documentation officielle de facturation GitHub Actions](https://docs.github.com/en/billing/concepts/product-billing/github-actions), puis rapprochez-les de votre propre suivi Copilot. Une commande supplémentaire peut donc modifier deux suivis budgétaires différents, sans que cela justifie à lui seul un Runner autogéré.

Le choix rapide selon le type de dépôt

Commencez par classer le dépôt, plutôt que par installer un Runner. Le tableau ci-dessous donne le choix par défaut et la condition qui doit vous faire changer de niveau.

| Situation du dépôt | Choix initial | Passage au niveau suivant | Ce que ce choix ne garantit pas | |---|---|---|---| | Dépôt public ou privé peu sensible, dépendances publiques | Runner GitHub hébergé standard | Échecs ou attente démontrés sur le même Pull Request | Ni fusion automatique sûre ni absence de code malveillant | | Monorepo, projet multilingue, installation lourde | Runner hébergé renforcé | Comparaison documentée des files, de la préparation et des échecs | Ni accès sûr aux réseaux internes ni protection des secrets | | Paquets privés, service de test interne, réseau contrôlé | Runner isolé géré par ARC | Impossible de limiter les sorties ou de récupérer automatiquement l’instance | Ni sécurité si le Runner reste partagé ou permanent | | Code hautement sensible, accès privilégié ou données de production | ARC avec identité et réseau dédiés, ou revue limitée | Absence de preuves d’isolement, de blocage et de destruction | Ni autorisation d’injecter des identifiants de production | | iOS et macOS avec Xcode, simulateur ou signature | Revue sur Runner compatible puis validation indépendante sur Mac | Résultat de build absent pour le même identifiant de commit | Ni construction Apple réelle sur le Runner Copilot |

Pour vérifier votre hypothèse dans un dépôt de test, conservez les journaux de la session, le SHA contrôlé et la liste des étapes exécutées. Un relevé minimal peut prendre cette forme :

```text commit: 8f31c2a review_environment: github-hosted-runner shell_steps: build, unit-tests, dependency-audit network_denials: 3 runner_lifecycle: destroyed merge_decision: human-review-required ```

Le format importe moins que la corrélation : vous devez pouvoir relier le commentaire de revue, la commande Shell, le résultat du test et la décision humaine au même commit.

Le cas des développeurs individuels et des petites équipes

Si votre dépôt contient du code applicatif sans accès à un réseau privé, conservez d’abord le Runner standard hébergé. L’environnement temporaire suffit généralement pour les vérifications classiques : compilation générale, tests unitaires, analyse statique et scripts de validation dont les dépendances sont publiques.

**Quelles commandes GitHub Copilot exécute-t-il sur le Runner ?** La réponse dépend du dépôt, de sa configuration et de ce que l’agent juge nécessaire. La capacité confirmée couvre les constructions, les tests et les scripts ciblés ; elle ne donne pas une liste universelle de commandes ni une fréquence fixe par Pull Request. Vous devez donc lire les journaux réels plutôt que supposer que toutes les étapes de votre pipeline seront exécutées.

Pour éviter une mauvaise fusion, séparez le processus en trois portes :

1. Copilot signale une anomalie ou demande une vérification. 2. Le test déterministe confirme ou invalide le comportement. 3. Une personne ou une règle de protection de branche décide de la fusion.

Un test vert signifie que la commande a abouti dans cet environnement. Il ne prouve pas que l’analyse a couvert toutes les branches, que le script n’a pas consulté une donnée indésirable ou que la dépendance utilisée est acceptable.

**Copilot code review doit-il utiliser un Runner hébergé ou autogéré ?** Pour un petit dépôt sans dépendance interne, choisissez le Runner hébergé. L’autogestion ajoute la maintenance de l’image, des correctifs, des permissions, du réseau, de la récupération après échec et de l’effacement. Ne payez pas cette complexité pour résoudre un problème que vous n’avez pas mesuré.

Le cas des grands dépôts et des équipes de plateforme

Un monorepo important n’est pas automatiquement un candidat à l’isolement. Il peut simplement manquer de ressources. Avant d’augmenter le Runner, répétez une comparaison sur des Pull Requests comparables et relevez :

- le temps passé en file d’attente ; - la durée de préparation de l’environnement ; - la réussite complète des tests ; - la cause précise des échecs ; - les étapes qui consomment le plus de processeur, de mémoire ou de disque.

Les Runner hébergés renforcés sont conçus pour fournir davantage de ressources ou des caractéristiques adaptées à la charge. Consultez les [paramètres officiels des Runner hébergés renforcés](https://docs.github.com/en/actions/how-tos/manage-runners/larger-runners/manage-larger-runners) avant de choisir une taille. Ne transformez pas une différence de taille en promesse de performance universelle : le gain dépend du workflow, des dépendances et du parallélisme.

**Comment savoir si le dépôt doit être agrandi ?** Si les journaux montrent principalement une attente de capacité, une saturation mémoire ou une préparation trop lente, testez le Runner renforcé. Si l’échec vient d’une permission, d’une sortie réseau ou d’un secret exposé, agrandir le Runner ne règle pas le problème. Dans ce cas, revenez à la conception des accès.

Une équipe de plateforme peut imposer une règle simple : aucune montée en gamme ne sera acceptée sans comparaison entre deux Pull Requests équivalents et une cause d’échec classée. Cette règle évite de confondre « dépôt volumineux » et « besoin d’une machine plus puissante ».

Le cas des dépendances internes et de l’isolement ARC

L’autogestion prend une valeur claire lorsqu’un agent doit atteindre un paquet privé, un service de test interne ou un réseau qui ne doit pas être exposé à un Runner partagé. Dans ce cas, utilisez la voie documentée par ARC et ses ensembles de Runner, plutôt qu’une machine persistante bricolée pour un seul dépôt. La [documentation ARC sur les ensembles de Runner](https://docs.github.com/en/actions/how-tos/manage-runners/use-actions-runner-controller/deploy-runner-scale-sets) décrit le mécanisme de gestion à retenir.

Votre conception doit imposer quatre propriétés :

1. **Cycle de vie temporaire :** le Runner est créé pour la tâche puis retiré automatiquement. 2. **Sorties réseau minimales :** seules les destinations indispensables sont autorisées. 3. **Identité dédiée :** aucun compte de production ni jeton réutilisé par les autres tâches. 4. **Séparation d’usage :** le Runner de revue ne sert ni aux déploiements de production, ni au CI quotidien, ni à d’autres agents.

La [référence GitHub sur les Runner autogérés](https://docs.github.com/en/actions/reference/runners/self-hosted-runners) rappelle que cette option transfère davantage de responsabilités à l’organisation. Le risque n’est pas supprimé parce que la machine appartient à votre infrastructure : il se déplace vers l’image, le réseau, les secrets et le nettoyage.

**Un Runner Copilot peut-il accéder aux dépendances internes et aux serveurs MCP ?** Oui, uniquement si votre architecture l’autorise explicitement et si les règles réseau, l’identité et les journaux couvrent chaque accès. Ce n’est pas un droit implicite accordé par ARC. Pour un dépôt sensible, désactivez les outils MCP non nécessaires et refusez l’injection de secrets de production.

Si vous ne pouvez pas limiter les sorties, vérifier les connexions et récupérer automatiquement l’instance, arrêtez le projet d’isolement. Conservez le Runner hébergé, réduisez la portée de la revue ou attendez d’avoir ces contrôles. Un Runner autogéré sans récupération fiable est un nouveau point permanent à défendre.

Le pare-feu d’agent et les serveurs MCP

Le pare-feu d’agent est un contrôle utile, mais sa portée doit être lue précisément. La [documentation GitHub consacrée à la configuration du pare-feu Copilot](https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-the-firewall) concerne certains processus de l’agent ; elle ne remplace pas le filtrage du Runner, la séparation des identités ou la protection des journaux.

Vérifiez séparément :

- les règles réseau de Copilot code review ; - les règles du cloud agent, si ce service est aussi utilisé ; - les étapes d’initialisation du dépôt ; - les scripts personnalisés ; - les extensions et serveurs MCP ; - les chemins de sortie non couverts par le processus surveillé.

La [documentation de configuration des serveurs MCP](https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/configure-mcp-servers) doit être examinée avec votre registre d’outils autorisés. Pour chaque serveur, notez la donnée accessible, l’identité utilisée, le sens des connexions et la condition de désactivation.

> **Expérience de gouvernance :** un pare-feu correctement configuré peut bloquer un chemin prévu, mais il ne rend pas inoffensif un script d’initialisation qui copie une variable d’environnement vers un fichier, ni un outil MCP autorisé trop largement.

Pour un dépôt à haute sensibilité, le réglage initial raisonnable est donc : MCP non essentiel désactivé, secrets de production absents, réseau sortant limité, et revue humaine obligatoire avant toute modification de protection de branche.

Le cas iOS et macOS : revue distincte du build réel

**Copilot code review peut-il fonctionner sur un Runner macOS ?** La voie autogérée officiellement documentée pour cette fonction est limitée à Ubuntu x64. Vous ne devez donc pas concevoir le Runner de revue comme un Runner de livraison Xcode. La revue de logique, les tests généraux et les contrôles de dépôt peuvent rester dans l’environnement Copilot compatible ; la construction Xcode, les tests de simulateur, la vérification de signature et les dépendances Apple doivent passer par une chaîne indépendante sur Mac.

Cette séparation est particulièrement importante pour les applications audio, vidéo et de design, où les ressources Apple, les outils de rendu, les simulateurs et les artefacts signés font partie du résultat attendu. Un commentaire positif sur le code ne prouve pas que l’archive Apple est constructible.

Associez les deux chaînes au même SHA :

```text pull_request: 1842 commit_sha: 8f31c2a copilot_review: passed-with-comments generic_tests: passed mac_xcode_build: passed signing_check: pending-human-approval ```

Une validation sur Mac dans le cloud peut être louée seulement pour cette étape, avec une conservation claire des artefacts et de l’identifiant de commit. Pour comparer les possibilités de [location de Mac selon la région](https://macwww.com/fr/achat.html), commencez par les besoins Xcode, simulateur, signature et accès réseau ; ne choisissez pas une configuration uniquement parce qu’elle ressemble au Runner de revue.

La politique d’entreprise et les preuves de sortie

Une organisation peut formaliser six classes de dépôts :

- **Public à faible risque :** Runner hébergé standard. - **Privé courant :** Runner hébergé standard, avec secrets limités. - **Grand dépôt :** Runner renforcé après mesure de la file et des échecs. - **Dépendances internes :** ARC avec réseau et identité dédiés. - **Code hautement sensible :** ARC isolé, MCP réduit et revue humaine stricte. - **Livraison Apple :** revue Copilot séparée, puis validation sur Mac au même SHA.

Pour chaque classe, indiquez si le dépôt peut remplacer la valeur par défaut de l’organisation. Une exception doit avoir un propriétaire, une date de réexamen et une preuve de retour arrière. Sans cette règle, les exceptions deviennent progressivement la configuration normale.

Le dossier de mise en production doit réunir au minimum :

- les appels Shell et leurs résultats ; - les connexions autorisées et bloquées ; - la preuve de récupération du Runner ; - les résultats de tests déterministes ; - l’identité du commit ; - l’approbation humaine de fusion ; - pour Apple, le résultat Xcode et la vérification de signature.

Vous pouvez utiliser le guide interne sur [l’isolement d’un Runner pour dépôt privé](https://macwww.com/fr/aide.html) pour structurer les points de contrôle opérationnels, puis documenter séparément la chaîne Mac. Ne mélangez pas une preuve de revue, une preuve de test et une preuve de livraison dans un seul indicateur « réussi ».

Le choix final pour votre architecture

Si votre solution actuelle utilise un Runner standard et des dépendances publiques, ne la remplacez pas préventivement : mesurez d’abord les files, les préparations et les échecs. Si le problème est réellement la capacité, essayez un Runner hébergé renforcé. Si le dépôt doit atteindre un réseau privé ou traiter un code très sensible, passez à ARC seulement avec cycle de vie temporaire, identité dédiée et sorties minimales.

Un Runner autogéré permanent présente des défauts concrets : surface d’administration plus large, nettoyage plus difficile, risque de réutilisation de secrets et mélange possible entre revue, CI et déploiement. À l’inverse, le Runner hébergé standard ne convient pas à une dépendance interne ni à la validation Xcode. Pour les projets Apple, confondre les deux environnements laisse une lacune : la revue peut réussir alors que le vrai build, le simulateur ou la signature échoue.

Si vous devez compléter cette chaîne par une validation Apple ponctuelle, MacWww permet de louer un Mac dans le cloud plutôt que de transformer le Runner Copilot en poste de livraison. Cette approche conserve les contrôles séparés : revue Shell dans son environnement, construction Xcode sur Mac, puis rapprochement des deux résultats par le même commit. Pour une charge lourde et stable, un Mac détenu en propre ou une capacité dédiée peut toutefois être plus cohérent qu’une location ponctuelle ; la location reste surtout adaptée à un besoin temporaire, à un test de capacité ou à une chaîne de validation que vous ne souhaitez pas maintenir en permanence.