Présentation
Les révisions de code sont plus efficaces lorsque vous passez moins de temps sur les détails de l’implémentation mineure, tels que les conventions de nommage et de style, et concentrez plutôt votre effort sur la conception de niveau supérieur, la résolution des problèmes et les fonctionnalités qui répondent aux besoins de l’utilisateur.
Dans cet article, nous allons montrer comment les révisions automatiques de Copilot peuvent vous aider à optimiser votre processus de révision afin de passer moins de temps sur les modifications mineures et plus de temps sur la résolution de problèmes nuancés et une compréhension plus approfondie de l’implémentation qui n’est pas simplement adéquate, mais qui répond de manière experte aux besoins de l’utilisateur.
1. Améliorer la qualité de la revue à partir de Copilot
révision du code Copilot peut fournir des révisions automatisées pour toutes les pull requests dans votre référentiel et rendre le processus de révision plus efficace en détectant les modifications indésirables dans votre code. Lorsqu’elles sont associées à des instructions personnalisées, elles sont plus efficaces, révision du code Copilot car elles peuvent fournir des réponses adaptées au fonctionnement de votre équipe, aux outils que vous utilisez ou aux spécificités de votre projet.
Les meilleures pratiques pour l’écriture d’instructions personnalisées sont les suivantes :
- Titres distincts
- Puces
- Instructions courtes et directes
Intéressons-nous à un exemple. Si vous créez un système de traitement des commandes à l'aide de Python, vos instructions personnalisées peuvent inclure une mise en forme, des performances et des pratiques de codage sécurisées spécifiques à Python, ainsi que des conseils directement pertinents pour votre projet. L’exemple suivant montre à quoi ressemblent quelques-unes des lignes de vos instructions personnalisées.
## Repository context
- This repository implements an order processing system (order intake, payment, fulfillment) where correctness, security, and auditability are critical.
## Style and conventions
- Follow the PEP 8 and PEP 257 style guide for Python.
- Use clear, domain-relevant names (orders, payments, inventory, customers, shipments).
- Prefer small, focused functions and methods with clearly defined responsibilities.
## Secure coding
- Verify proper input validation and sanitization.
- Review authentication and authorization logic.
## Error handling guidelines
- Handle timeouts and network errors gracefully.
- Ensure failures are logged with enough detail for debugging.
## Order processing context
- Ensure order creation, payment handling, and updates are idempotent to avoid duplicate orders or duplicate charges.
- Validate and normalize all order, payment, and customer data before persisting or acting on it.
- Do not log or persist sensitive data (passwords, raw payment details, full identifiers) without hashing, encryption, or redaction.
- Call out obvious performance issues in core order workflows (e.g., N+1 queries, per-order synchronous network calls) and suggest simpler, more efficient alternatives.
## Review style
- Be concise, specific and actionable.
- Explain the "why" behind recommendations using bullet points.
Dans la section suivante, nous allons montrer comment nos exemples d'instructions personnalisées peuvent influencer positivement les commentaires de relecture que Copilot propose pour une pull request.
2. Automatiser les révisions pour traiter les conventions de style et les performances
Lorsque l’option automatique révision du code Copilot est activée, Copilot examinera automatiquement une pull request une fois qu’elle est hors brouillon.
Imaginez que vous soumettez une demande de tirage contenant la fonction suivante pour mettre à jour l'inventaire dans votre système de traitement des commandes.
def notify_inventory(product_id, quantity):
requests.post("http://inventory-service/update", json={"product_id": product_id, "quantity": quantity})
Bien que cela soit fonctionnel, il manque de clarté et de robustesse. L’intention des types est implicite, il n’y a pas de docstrings, et elle n’inclut pas la gestion des erreurs ou la journalisation, ce qui rend difficile si la notification a réellement fonctionné.
Copilot passera en revue le code et pourra formuler le commentaire et la suggestion de code suivants.
Remarque
La réponse suivante est un exemple. Les réponses Copilot Chat ne sont pas déterministes, vous pouvez donc obtenir une réponse différente de celle affichée ici.
Missing error handling for network calls
The notify_inventory function makes a synchronous network call without any error handling for timeouts, connection failures, or non-200 responses.
Why this matters:
- Network failures will cause unhandled exceptions and crash the order processing flow
- Orders could be marked as CONFIRMED but inventory never gets updated
- This violates the requirement to "handle timeouts and network errors gracefully"
- Failures won't be logged with enough detail for debugging
Recommendation: Add proper error handling with timeout and logging:
def notify_inventory(product_id: str, quantity: int) -> bool:
"""Notify the inventory service of order placement.
Args:
product_id: The product identifier.
quantity: The quantity ordered.
Returns:
True if the notification succeeded; False otherwise.
"""
try:
response = requests.post(
"http://inventory-service/update",
json={"product_id": product_id, "quantity": quantity},
timeout=5,
)
response.raise_for_status()
logger.info(
"Inventory notified for product %s, quantity %d (status %d)",
product_id,
quantity,
response.status_code,
)
return True
except requests.exceptions.Timeout:
logger.error(
"Timeout notifying inventory for product %s, quantity %d",
product_id,
quantity,
exc_info=True,
)
except requests.exceptions.RequestException:
logger.error(
"Failed to notify inventory for product %s, quantity %d",
product_id,
quantity,
exc_info=True,
)
return False
La réponse de Copilot suit vos instructions personnalisées dans sa recommandation. Dans cet exemple, il suit les conseils de style PEP 8 et 257 pour Python et suggère une amélioration pour mieux gérer les délais d’attente et la journalisation des erreurs, tout en expliquant de manière concise le raisonnement derrière les suggestions.
Remarque
Passez toujours attentivement en revue les suggestions de Copilot avant d’accepter et de valider.
Les commentaires de révision automatique comme ceux-ci vous aident à créer votre propre compréhension lorsque vous codez ou pouvez vous aider à vous concentrer et à affiner les commentaires donnés à d’autres personnes lors de l’examen.
3. Marquer les vulnérabilités de sécurité et les corriger
Ensuite, imaginez que vous avez été chargé d’améliorer la façon dont les mots de passe sont stockés dans votre système de traitement des commandes. Vous soumettez une pull request avec du code qui, selon vous, hachait suffisamment les mots de passe des utilisateurs pour les protéger.
def get_password_hash(password: str, salt: str) -> str:
"""Hash a password with the given salt using SHA-256.
Returns the hexadecimal representation of the hashed password.
"""
return hashlib.sha256((password + salt).encode()).hexdigest()
class User:
"""Represents a user in the order processing system."""
def __init__(self, username: str, password: str, salt: str):
"""Initialize a User with username, password, and salt.
The password is hashed and stored for authentication.
"""
self.username = username
self.salt = salt
self.password_hash = get_password_hash(password, self.salt)
def verify_password(self, password: str) -> bool:
"""Verify a plain-text password against the stored hash."""
return get_password_hash(password, self.salt) == self.password_hash
Toutefois, dans cet exemple, l’utilisation de SHA-256 n’est pas acceptable, car elle n’est pas suffisamment coûteuse pour protéger les mots de passe utilisateur.
Bien que révision du code Copilot puisse faire des suggestions de bonnes pratiques en matière de sécurité, Copilot correction automatique pour code scanning va plus loin. Tirer parti des fonctionnalités d’analyse code scanningCodeQL pour analyser le code dans un GitHub référentiel et rechercher des vulnérabilités de sécurité et des erreurs de codage, Copilot correction automatique peut ensuite suggérer des correctifs pour les alertes, ce qui vous permet d’empêcher et de réduire les vulnérabilités plus efficacement.
Par exemple, Copilot correction automatique peut faire le commentaire suivant sur le code.
Using SHA-256 for password hashing is insecure for authentication systems. SHA-256 is designed to be fast, making it vulnerable to brute-force attacks.
To fix the problem, use a password-specific hashing algorithm like bcrypt, scrypt, or argon2 (e.g., `argon2-cffi` from the PyPI package) which are designed to be slow and include built-in salting mechanisms.
Copilot correction automatique fera également des suggestions de code pour une correction potentielle de la vulnérabilité à examiner. Dans ce cas, il peut faire des suggestions de code, comme celles ci-dessous, pour importer un package et mettre à jour le code lié au hachage du mot de passe.
from argon2 import PasswordHasher
def get_initial_hash(password: str):
ph = PasswordHasher()
return ph.hash(password)
def check_password(password: str, known_hash):
ph = PasswordHasher()
return ph.verify(known_hash, password)
Remarque
- Vérifiez et validez toujours les modifications Copilot qu’il suggère avant de les accepter.
- Dans cet exemple, révision du code Copilot peut également mettre en évidence la nécessité de générer des sels uniques.
Comme vous pouvez le voir, l’identification automatique des vulnérabilités, ainsi que les suggestions de résolution de ces vulnérabilités, vous aide à établir une priorité de sécurité. Copilot correction automatique vous permet de vous concentrer sur la compréhension du codage sécurisé et sur les correctifs qui fonctionnent le mieux pour votre base de code et votre projet.
Révisions optimisées avec Copilot
Les commentaires de révision automatique vous aident à optimiser vos révisions et à sécuriser votre code de manière plus efficace, quel que soit votre niveau d’expérience.
- Les instructions personnalisées ont permis d’affiner révision du code Copilot les réponses de telle sorte qu’elles étaient spécifiques à nos besoins de projet et d’utilisateur, et nous avons également vu comment nous pouvons adapter la quantité d’explications Copilot fournies dans les commentaires.
- révision du code Copilot nous a aidés à améliorer rapidement notre journalisation des erreurs et à comprendre pourquoi c’était important.
- Copilot correction automatique pour code scanning nous a aidé à empêcher l’utilisation d’une approche de hachage de mot de passe insuffisante et à protéger les données utilisateur.
Étapes suivantes
Pour rendre vos révisions plus efficaces et plus efficaces à l’aide Copilotdes fonctionnalités de révision, commencez par suivre ces étapes.
- Créez des instructions personnalisées spécifiques à votre project et à votre référentiel. Écrivez votre propre fichier ou inspirez-vous de notre bibliothèque d’exemples. Consultez Instructions personnalisées.
- Pour activer la fonctionnalité automatique de révision du code Copilot pour votre référentiel, consultez Configuration de la révision automatique du code par GitHub Copilot.
- Pour configurer Copilot correction automatique pour votre dépôt, vous devez activer code scanning. Une fois l’analyse code scanningCodeQL activée, Copilot correction automatique est activé par défaut. Pour obtenir la configuration la plus simple, consultez Définition de la configuration par défaut pour l’analyse du code.
Lectures complémentaires
Pour approfondir l’examen du code généré par l’IA, consultez Passer en revue le code généré par l’IA.