{"meta":{"title":"Préparation de votre code pour l’analyse CodeQL","intro":"Vous pouvez créer une base de données CodeQL contenant les données nécessaires pour analyser votre code.","product":"Sécurité et qualité du code","breadcrumbs":[{"href":"/fr/code-security","title":"Sécurité et qualité du code"},{"href":"/fr/code-security/tutorials","title":"Tutorials"},{"href":"/fr/code-security/tutorials/customize-code-scanning","title":"Personnaliser l’analyse du code"},{"href":"/fr/code-security/tutorials/customize-code-scanning/preparing-your-code-for-codeql-analysis","title":"Préparation du code pour l’analyse"}],"documentType":"article"},"body":"# Préparation de votre code pour l’analyse CodeQL\n\nVous pouvez créer une base de données CodeQL contenant les données nécessaires pour analyser votre code.\n\n\n\n## À propos de la préparation du code pour l’analyse\n\nAvant d’analyser votre code avec CodeQL, vous devez créer une base de données CodeQL contenant toutes les données nécessaires pour exécuter des requêtes sur votre code. Vous pouvez créer vous-même des bases de données CodeQL en utilisant CodeQL CLI.\n\nL’analyse CodeQL repose sur l’extraction de données relationnelles de votre code et sur leur utilisation pour créer une [base de données CodeQL](https://codeql.github.com/docs/codeql-overview/codeql-glossary/#codeql-database). Les bases de données CodeQL contiennent toutes les informations importantes relatives à un codebase, qui peuvent être analysées en exécutant des requêtes CodeQL dessus.\n\nAvant de générer une base de données CodeQL, vous devez :\n\n1. Installer et configurer CodeQL CLI Pour plus d’informations, consultez « [Configuration de CodeQL CLI](/fr/code-security/codeql-cli/getting-started-with-the-codeql-cli/setting-up-the-codeql-cli) ».\n2. Extrayez le code à analyser :\n * Pour une branche, extrayez la tête (début) de la branche à analyser.\n * Pour une demande de tirage, extrayez son commit de tête ou un commit de fusion généré par GitHub.\n3. Configurez l’environnement pour le codebase, en vérifiant que toutes les dépendances sont disponibles.\n4. Pour obtenir les meilleurs résultats avec des langages compilés, recherchez la commande de génération, le cas échéant, pour la codebase. En général, celle-ci est disponible dans un fichier de configuration dans le système CI.\n\nUne fois le codebase prêt, vous pouvez exécuter `codeql database create` pour créer la base de données. Pour plus d’informations, consultez [Création de bases de données pour les langages non compilés](#creating-databases-for-non-compiled-languages) et [Création de bases de données pour les langages compilés](#creating-databases-for-compiled-languages).\n\n## En cours d’exécution `codeql database create`\n\nLes bases de données CodeQL sont créées en exécutant la commande suivante à partir de la racine d’extraction de votre projet :\n\n```shell\ncodeql database create --language=\n```\n\nVous devez spécifier :\n\n* `` : chemin de la nouvelle base de données à créer. Ce répertoire est créé lorsque vous exécutez la commande. Vous ne pouvez pas spécifier de répertoire existant.\n* `--language` : identificateur du langage pour lequel créer une base de données. Utilisée avec `--db-cluster`, l’option accepte une liste séparée par des virgules ou peut être spécifiée plusieurs fois. CodeQL prend en charge la création de bases de données pour les langages suivants :\n\n | Langage | Identificateur | Identificateurs alternatifs facultatifs (le cas échéant) |\n | ------------------------ | ----------------------- | -------------------------------------------------------- |\n | C/C++ | `c-cpp` | `c` ou `cpp` |\n | C# | `csharp` | |\n | | | |\n | Workflows GitHub Actions | `actions` | |\n | | | |\n | Go | `go` | |\n | Java/Kotlin | `java-kotlin` | `java` ou `kotlin` |\n | JavaScript/TypeScript | `javascript-typescript` | `javascript` ou `typescript` |\n | Python | `python` | |\n | Ruby | `ruby` | |\n | | | |\n | Rust | `rust` | |\n | | | |\n | Swift | `swift` | |\n\n > \\[!NOTE]\n > Si vous spécifiez l'un des identificateurs alternatifs, cela équivaut à l'utilisation de l'identificateur de langue standard. Par exemple, la spécification `javascript` au lieu de `javascript-typescript` n’exclut pas l’analyse du code TypeScript. Vous pouvez également utiliser l’option `--codescanning-config` de l’interface de ligne de commande pour charger un fichier de configuration qui spécifie les fichiers à exclure avec la clé de configuration `paths-ignore`. Consultez « [Options de configuration de flux de travail pour l’analyse du code](/fr/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning#custom-configuration-files) ».\n >\n > Sinon, pour les langages qui le prennent en charge, utilisez une commande de génération personnalisée qui ne génère que les fichiers que vous souhaitez analyser. Consultez [Création de bases de données pour les langages compilés](/fr/code-security/codeql-cli/getting-started-with-the-codeql-cli/preparing-your-code-for-codeql-analysis#creating-databases-for-compiled-languages).\n\nSi votre codebase dispose d'une commande ou d'un script de construction qui invoque le processus de construction, nous vous recommandons de le spécifier également :\n\n```shell\n codeql database create --command \\\n --language=\n```\n\n### Options de création de bases de données\n\nVous pouvez spécifier des options supplémentaires en fonction de l’emplacement de votre fichier source, si le code doit être compilé et si vous voulez créer des bases de données CodeQL pour plusieurs langages.\n\n| Choix | Obligatoire | Usage |\n| ----------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `` | | Spécifiez le nom et l’emplacement d’un répertoire à créer pour la base de données CodeQL. La commande échoue si vous essayez de remplacer un répertoire existant. Si vous spécifiez aussi `--db-cluster`, il s’agit du répertoire parent et un sous-répertoire est créé pour chaque langage analysé. |\n| --language | | Spécifiez l’identificateur de la langue pour laquelle vous souhaitez créer une base de données, l’une des suivantes : `c-cpp`, `csharp`, `go`, `java-kotlin`, `javascript-typescript`, `python`, `ruby`, `rust`, et `swift`. Utilisée avec --db-cluster, l’option accepte une liste séparée par des virgules ou peut être spécifiée plusieurs fois. |\n| --command | | |\n\n```\n **Recommandé.** Utilisez cette option pour spécifier la commande de génération ou le script qui appelle le processus de génération pour le codebase. Les commandes sont exécutées à partir du dossier actuel ou de --source-root si ce dernier est défini. Non nécessaire pour l’analyse Python et JavaScript/TypeScript. |\n```\n\n\\| --build-mode | |\n**Recommandé.** À utiliser pour C/C++, C#, Java et Rust lorsqu'une `--command` n'est pas fournie pour spécifier la création ou non d'une base de données CodeQL sans build (`none`) ou lors de la tentative de détection automatique d'une commande de build (`autobuild`). Par défaut, la détection automatique de build est utilisé. Pour obtenir une comparaison des modes de build, consultez [Modes de build CodeQL](/fr/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages#codeql-build-modes). |\n\\| --db-cluster | | Utilisez cette option dans les codebases en plusieurs langages pour générer une seule base de données pour chaque langage spécifié par --language. |\n\\| --no-run-unnecessary-builds | |\n**Recommandé.** Permet de supprimer la commande de génération pour les langues où CodeQL CLI n’a pas besoin de surveiller la build (par exemple, Python et JavaScript/TypeScript). |\n\\| --source-root | | Utilisez cette option si vous exécutez l’interface CLI en dehors de la racine d’extraction du dépôt. Par défaut, la commande `database create` suppose que le répertoire actuel est le répertoire racine des fichiers sources. Utilisez cette option pour spécifier un autre emplacement. |\n\\| --codescanning-config | | Avancé. À utiliser si vous avez un fichier de configuration qui spécifie comment créer les bases de données CodeQL et quelles requêtes exécuter dans des étapes ultérieures. Pour plus d’informations, consultez « [Options de configuration de flux de travail pour l’analyse du code](/fr/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning#custom-configuration-files) » et « [création de base de données](/fr/code-security/codeql-cli/codeql-cli-manual/database-create#--codescanning-configfile) ». |\n\nVous pouvez spécifier des options d’extracteur pour personnaliser le comportement des extracteurs qui créent les bases de données CodeQL. Pour plus d’informations, consultez « [Options d’extracteur](/fr/code-security/codeql-cli/using-the-advanced-functionality-of-the-codeql-cli/extractor-options) ».\n\nPour des détails complets sur toutes les options que vous pouvez utiliser lors de la création de bases de données, consultez [création de base de données](/fr/code-security/codeql-cli/codeql-cli-manual/database-create).\n\n### Exemple avec un langage unique\n\nCet exemple crée une base de données CodeQL simple pour le dépôt extrait à l’emplacement `/checkouts/example-repo`. Il utilise l’extracteur JavaScript pour créer une représentation hiérarchique du code JavaScript et TypeScript dans le dépôt. La base de données obtenue est stockée dans `/codeql-dbs/example-repo`.\n\n```shell\n$ codeql database create /codeql-dbs/example-repo --language=javascript-typescript \\\n --source-root /checkouts/example-repo\n\n> Initializing database at /codeql-dbs/example-repo.\n> Running command [/codeql-home/codeql/javascript/tools/autobuild.cmd]\n in /checkouts/example-repo.\n> [build-stdout] Single-threaded extraction.\n> [build-stdout] Extracting\n...\n> Finalizing database at /codeql-dbs/example-repo.\n> Successfully created database at /codeql-dbs/example-repo.\n```\n\n### Exemple avec plusieurs langages\n\nCet exemple crée deux bases de données CodeQL pour le dépôt extrait à l’emplacement `/checkouts/example-repo-multi`. Il utilise :\n\n* `--db-cluster` pour demander l’analyse de plusieurs langages.\n* `--language` pour spécifier les langages pour lesquels créer des bases de données.\n* `--command` pour indiquer à l’outil la commande de génération pour le codebase, ici `make`.\n* `--no-run-unnecessary-builds` pour indiquer à l’outil d’ignorer la commande de build pour les langues où il n’est pas nécessaire (comme Python).\n\nLes bases de données obtenues sont stockées dans les sous-répertoires `python` et `cpp` de `/codeql-dbs/example-repo-multi`.\n\n```shell\n$ codeql database create /codeql-dbs/example-repo-multi \\\n --db-cluster --language python,c-cpp \\\n --command make --no-run-unnecessary-builds \\\n --source-root /checkouts/example-repo-multi\nInitializing databases at /codeql-dbs/example-repo-multi.\nRunning build command: [make]\n[build-stdout] Calling python3 /codeql-bundle/codeql/python/tools/get_venv_lib.py\n[build-stdout] Calling python3 -S /codeql-bundle/codeql/python/tools/python_tracer.py -v -z all -c /codeql-dbs/example-repo-multi/python/working/trap_cache -p ERROR: 'pip' not installed.\n[build-stdout] /usr/local/lib/python3.6/dist-packages -R /checkouts/example-repo-multi\n[build-stdout] [INFO] Python version 3.6.9\n[build-stdout] [INFO] Python extractor version 5.16\n[build-stdout] [INFO] [2] Extracted file /checkouts/example-repo-multi/hello.py in 5ms\n[build-stdout] [INFO] Processed 1 modules in 0.15s\n[build-stdout] \nFinalizing databases at /codeql-dbs/example-repo-multi.\nSuccessfully created databases at /codeql-dbs/example-repo-multi.\n$\n```\n\n## Progression et résultats\n\nDes erreurs sont signalées en cas de problèmes avec les options que vous avez spécifiées. Pour les langages interprétés et lorsque vous spécifiez `--build-mode none` pour C/C++, C#, Java et Rust, la progression de l’extraction s’affiche dans la console. Pour chaque fichier source, la console indique si l’extraction a réussi ou si elle a échoué. Lorsqu'un langage compilé est conçu, la console affiche la sortie du système de build.\n\nUne fois la base de données créée, vous trouverez un nouveau répertoire dans le chemin spécifié dans la commande. Si vous avez utilisé l’option `--db-cluster` pour créer plusieurs bases de données, un sous-répertoire est créé pour chaque langage. Chaque répertoire de base de données CodeQL contient un certain nombre de sous-répertoires, notamment les données relationnelles (requises pour l’analyse) et une archive source (une copie des fichiers sources créée au moment de la création de la base de données) qui est utilisée pour afficher les résultats de l’analyse.\n\n## Création de bases de données pour les langages non compilés\n\nLe CodeQL CLI inclut des extracteurs pour créer des bases de données pour des langages non compilés, en particulier JavaScript (et TypeScript), Python et Ruby. Ces extracteurs sont automatiquement appelés lorsque vous spécifiez JavaScript, Python ou Ruby comme option `--language` lors de l’exécution de `database create`. Lorsque vous créez des bases de données pour ces langages, vous devez vous assurer que toutes les dépendances supplémentaires sont disponibles.\n\n> \\[!NOTE]\n> Lorsque vous exécutez `database create` pour JavaScript, TypeScript, Python et Ruby, vous ne devez pas spécifier d’option `--command`. Sinon, cela remplace l’appel de l’extracteur normal, ce qui crée une base de données vide. Si vous créez des bases de données pour plusieurs langages et que l’un d’eux est un langage compilé, utilisez l’option `--no-run-unnecessary-builds` pour ignorer la commande pour les langages qui n’ont pas besoin d’être compilés.\n\n### JavaScript et TypeScript\n\nLa création de bases de données pour JavaScript ne nécessite aucune dépendance supplémentaire. Toutefois, si le projet inclut des fichiers TypeScript, Node.js 14 ou une version plus récente doit être installé et disponible sur le serveur `PATH` comme `node`. Dans la ligne de commande, vous pouvez spécifier `--language=javascript-typescript` pour extraire les fichiers JavaScript et TypeScript :\n\n```shell\ncodeql database create --language=javascript-typescript --source-root /javascript-database\n```\n\nIci, nous avons spécifié un chemin `--source-root`, qui est l’emplacement où la création de la base de données est exécutée, mais qui n’est pas nécessairement la racine d’extraction du codebase.\n\nPar défaut, les fichiers dans les répertoires `node_modules` et `bower_components` ne sont pas extraits.\n\n### Python\n\nLors de la création de bases de données pour Python vous devez vous assurer :\n\n* Vous avez Python 3 installé et disponible pour l'extracteur CodeQL.\n* Vous disposez de la version de Python utilisée par votre code installé.\n\nDans la ligne de commande, vous devez spécifier `--language=python`. Par exemple:\n\n```shell\ncodeql database create --language=python /python-database\n```\n\nCette opération exécute la sous-commande `database create` à partir de la racine d’extraction du code, générant une nouvelle base de données Python dans `/python-database`.\n\n### Ruby\n\nLa création de bases de données pour Ruby ne demande aucune dépendance supplémentaire. Dans la ligne de commande, vous devez spécifier `--language=ruby`. Par exemple:\n\n```shell\ncodeql database create --language=ruby --source-root /ruby-database\n```\n\nIci, nous avons spécifié un chemin `--source-root`, qui est l’emplacement où la création de la base de données est exécutée, mais qui n’est pas nécessairement la racine d’extraction du codebase.\n\n## Création de bases de données pour les langages compilés\n\nPour la plupart des langages compilés, CodeQL doit appeler le système de build requis pour générer une base de données. Par conséquent, la méthode de build doit être disponible pour l’interface CLI. Cette approche crée des bases de données qui incluent du code généré. CodeQL dispose de deux méthodes pour générer des codebases :\n\n* [Détection de build automatique (build automatique)](#automatically-detecting-the-build-system)\n* [Commandes de build spécifiées par l’utilisateur](/fr/code-security/codeql-cli/getting-started-with-the-codeql-cli/preparing-your-code-for-codeql-analysis#specifying-build-commands)\n\nEn outre, pour C/C++, C#, Java et Rust, il existe une option permettant de générer une base de données sans générer le code. Cela est particulièrement utile lorsque vous souhaitez activer code scanning pour de nombreux référentiels. Pour plus d’informations, consultez [Modes de génération CodeQL](/fr/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages#codeql-build-modes).\n\n### Détection automatique du système de génération\n\nLe CodeQL CLI inclut des générateurs automatiques pour le code C/C++, C#, Go, Java, Kotlin et Swift. Les générateurs automatiques CodeQL vous permettent de générer des projets pour les langages compilés sans spécifier de commandes de build. Quand un générateur automatique est appelé, CodeQL examine la source pour confirmer la présence d’un système de build et tente d’exécuter le jeu optimal de commandes requises pour extraire une base de données. Pour plus d’informations, consultez « [Analyse CodeQL pour les langages compilés](/fr/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages#about-autobuild) ».\n\nUn générateur automatique est appelé automatiquement lorsque vous exécutez `codeql database create` pour un langage compilé si vous n’incluez pas d’option `--command` ou d'ensemble `--build-mode none`. Par exemple, pour un codebase Swift, vous pouvez exécuter simplement :\n\n```shell\ncodeql database create --language=swift /swift-database\n```\n\nSi un codebase utilise un système de build standard, s’appuyer sur un générateur automatique est souvent le moyen le plus simple de créer une base de données. Pour les sources qui demandent des étapes de génération non standard, vous devrez peut-être définir explicitement chaque étape dans la ligne de commande.\n\n> \\[!NOTE]\n>\n> * Si vous créez une base de données Go, installez la chaîne d’outils Go (version 1.11 ou ultérieure) et, s’il existe des dépendances, le gestionnaire de dépendances approprié (par exemple [dep](https://golang.github.io/dep/)).\n> * Le générateur automatique Go tente de détecter automatiquement le code écrit en Go dans un dépôt et exécute uniquement les scripts de build dans une tentative de récupération des dépendances. Pour forcer CodeQL à limiter l’extraction aux fichiers compilés par votre script de build, définissez la variable d’environnement `CODEQL_EXTRACTOR_GO_BUILD_TRACING=on` ou utilisez l’option `--command` pour spécifier une commande de build.\n\n### Spécification des commandes de build\n\nLes exemples suivants sont conçus pour vous donner une idée de quelques commandes de build que vous pouvez spécifier pour les langages compilés.\n\n> \\[!NOTE]\n> L’option `--command` accepte un seul argument. Si vous devez utiliser plusieurs commandes, spécifiez `--command` plusieurs fois. Si vous devez passer des sous-commandes et des options, l’argument entier doit être entre guillemets pour être interprété correctement.\n\n* Projet C/C++ généré avec `make` :\n\n ```shell\n # Disable parallel execution via `-j1` or other techniques: https://www.gnu.org/software/make/manual/make.html#Parallel-Execution\n codeql database create cpp-database --language=c-cpp --command=make\n ```\n\n* Projet C# généré avec `dotnet build` :\n\n Il est judicieux d’ajouter `/t:rebuild` pour vous assurer que tout le code sera généré ou d’effectuer un `dotnet clean` avant (le code qui n’est pas généré ne sera pas inclus dans la base de données CodeQL) :\n\n ```shell\n codeql database create csharp-database --language=csharp --command='dotnet build /t:rebuild'\n ```\n\n* Projet Go généré avec la variable d’environnement `CODEQL_EXTRACTOR_GO_BUILD_TRACING=on` :\n\n ```shell\n CODEQL_EXTRACTOR_GO_BUILD_TRACING=on codeql database create go-database --language=go\n ```\n\n* Projet Go généré avec un script de build personnalisé :\n\n ```shell\n codeql database create go-database --language=go --command='./scripts/build.sh'\n ```\n\n* Projet Java construit à l’aide de Gradle :\n\n ```shell\n # Use `--no-daemon` because a build delegated to an existing daemon cannot be detected by CodeQL.\n # To ensure isolated builds without caching, add `--no-build-cache` on persistent machines.\n codeql database create java-database --language=java-kotlin --command='gradle --no-daemon clean test'\n ```\n\n* Projet Java construit à l’aide de Maven :\n\n ```shell\n codeql database create java-database --language=java-kotlin --command='mvn clean install'\n ```\n\n* Projet Java construit à l’aide d’Ant :\n\n ```shell\n codeql database create java-database --language=java-kotlin --command='ant -f build.xml'\n ```\n\n* Projet Rust créé à l’aide de Cargo :\n\n ```shell\n codeql database create rust-database --language=rust\n ```\n\n* Projet Swift créé à partir d’un projet ou d’un espace de travail Xcode. Par défaut, la plus grande cible Swift est générée :\n\n Il est conseillé de s'assurer que le projet est dans un état propre et qu'il n'y a pas d'artefacts de génération disponibles.\n\n ```shell\n xcodebuild clean -all\n codeql database create -l swift swift-database\n ```\n\n* Projet Swift généré avec `swift build` :\n\n ```shell\n codeql database create -l swift -c \"swift build\" swift-database\n ```\n\n* Projet Swift généré avec `xcodebuild` :\n\n ```shell\n codeql database create -l swift -c \"xcodebuild build -target your-target\" swift-database\n ```\n\n Vous pouvez passer les options `archive` et `test` à `xcodebuild`. Toutefois, la commande standard `xcodebuild` est recommandée, car elle doit être la plus rapide et doit être tout ce que CodeQL nécessite pour une analyse réussie.\n\n* Projet Swift généré avec un script de build personnalisé :\n\n ```shell\n codeql database create -l swift -c \"./scripts/build.sh\" swift-database\n ```\n\n* Projet généré avec Bazel :\n\n ```shell\n # Navigate to the Bazel workspace.\n\n # Before building, remove cached objects\n # and stop all running Bazel server processes.\n bazel clean --expunge\n\n # Build using the following Bazel flags, to help CodeQL detect the build:\n # `--spawn_strategy=local`: build locally, instead of using a distributed build\n # `--nouse_action_cache`: turn off build caching, which might prevent recompilation of source code\n # `--noremote_accept_cached`, `--noremote_upload_local_results`: avoid using a remote cache\n # `--disk_cache=`: avoid using a disk cache. Note that a disk cache is no longer considered a remote cache as of Bazel 6.\n codeql database create new-database --language= \\\n --command='bazel build --spawn_strategy=local --nouse_action_cache --noremote_accept_cached --noremote_upload_local_results --disk_cache= //path/to/package:target'\n\n # After building, stop all running Bazel server processes.\n # This ensures future build commands start in a clean Bazel server process\n # without CodeQL attached.\n bazel shutdown\n ```\n\n> \\[!NOTE]\n> La build Bazel pour Go n’est actuellement pas prise en charge.\n\n* Projet généré avec un script de build personnalisé :\n\n ```shell\n codeql database create new-database --language= --command='./scripts/build.sh'\n ```\n\nCette commande exécute un script personnalisé qui contient toutes les commandes requises pour générer le projet.\n\n\n\n\n\n### Utilisation du traçage de build indirect\n\nSi les générateurs automatiques CodeQL CLI pour les langages compilés ne fonctionnent pas avec votre workflow CI et que vous ne pouvez pas wrapper les appels de commandes de build avec `codeql database trace-command`, vous pouvez utiliser le traçage de build indirect pour créer une base de données CodeQL. Pour utiliser le traçage de build indirect, votre système CI doit être en mesure de définir des variables d’environnement personnalisées pour chaque action de génération.\n\nPour créer une base de données CodeQL avec le traçage de build indirect, exécutez la commande suivante à partir de la racine d’extraction de votre projet :\n\n```shell\ncodeql database init ... --begin-tracing \n```\n\nVous devez spécifier :\n\n* `` : chemin de la nouvelle base de données à créer. Ce répertoire est créé lorsque vous exécutez la commande. Vous ne pouvez pas spécifier de répertoire existant.\n* `--begin-tracing` : crée des scripts qui peuvent être utilisés pour configurer un environnement dans lequel les commandes de build seront tracées.\n\nVous pouvez spécifier d’autres options pour la commande `codeql database init` comme d’habitude.\n\n> \\[!NOTE]\n> Si la build s’exécute sur Windows, vous devez définir `--trace-process-level ` ou `--trace-process-name ` afin que l’option pointe vers un processus CI parent qui observera toutes les étapes de génération du code en cours d’analyse.\n\nLa commande `codeql database init` génère un message :\n\n```shell\nCreated skeleton . This in-progress database is ready to be populated by an extractor. In order to initialise tracing, some environment variables need to be set in the shell your build will run in. A number of scripts to do this have been created in /temp/tracingEnvironment. Please run one of these scripts before invoking your build command.\n\nBased on your operating system, we recommend you run: ...\n```\n\nLa commande `codeql database init` crée `/temp/tracingEnvironment` avec des fichiers qui contiennent des variables d’environnement et des valeurs qui permettent à CodeQL de tracer une séquence d’étapes de génération. Ces fichiers sont appelés `start-tracing.{json,sh,bat,ps1}`. Utilisez l’un de ces fichiers avec le mécanisme de votre système CI afin de définir les variables d’environnement pour les étapes futures. Vous pouvez:\n\n* Lisez le fichier JSON, traitez-le et affichez les variables d’environnement au format attendu par votre système CI. Par exemple, Azure DevOps attend `echo \"##vso[task.setvariable variable=NAME]VALUE\"`.\n* Ou, si votre système CI conserve l’environnement, sourcez le script `start-tracing` approprié pour définir les variables CodeQL dans l’environnement shell du système CI.\n\nGénérez votre code, et annulez si vous voulez les variables d’environnement à l’aide d’un script `end-tracing.{json,sh,bat,ps1}` du répertoire où les scripts `start-tracing` sont stockés, puis exécutez la commande `codeql database finalize `.\n\nUne fois que vous avez créé une base de données CodeQL à l’aide du traçage de build indirect, vous pouvez l’utiliser comme n’importe quelle autre base de données CodeQL. Par exemple, analysez la base de données et chargez les résultats dans GitHub si vous utilisez l’analyse du code.\n\n### Exemple de création d’une base de données CodeQL à l’aide du traçage de build indirect\n\n> \\[!NOTE]\n> Si vous utilisez des pipelines Azure DevOps, le moyen le plus simple de créer une base de données CodeQL consiste à utiliser GitHub Advanced Security for Azure DevOps. Pour obtenir de la documentation, consultez [Configurer GitHub Advanced Security for Azure DevOps](https://learn.microsoft.com/en-us/azure/devops/repos/security/configure-github-advanced-security-features) dans Microsoft Learn.\n\nL’exemple suivant montre comment utiliser le suivi de build indirect dans un pipeline Azure DevOps pour créer une base de données CodeQL :\n\n```yaml\nsteps:\n # Download the CodeQL CLI and query packs...\n # Check out the repository ...\n\n # Run any pre-build tasks, for example, restore NuGet dependencies...\n\n # Initialize the CodeQL database.\n # In this example, the CodeQL CLI has been downloaded and placed on the PATH.\n - task: CmdLine@1\n displayName: Initialize CodeQL database\n inputs:\n # Assumes the source code is checked out to the current working directory.\n # Creates a database at `/db`.\n # Running on Windows, so specifies a trace process level.\n script: \"codeql database init --language csharp --trace-process-name Agent.Worker.exe --source-root . --begin-tracing db\"\n\n # Read the generated environment variables and values,\n # and set them so they are available for subsequent commands\n # in the build pipeline. This is done in PowerShell in this example.\n - task: PowerShell@1\n displayName: Set CodeQL environment variables\n inputs:\n targetType: inline\n script: >\n $json = Get-Content $(System.DefaultWorkingDirectory)/db/temp/tracingEnvironment/start-tracing.json | ConvertFrom-Json\n $json.PSObject.Properties | ForEach-Object {\n $template = \"##vso[task.setvariable variable=\"\n $template += $_.Name\n $template += \"]\"\n $template += $_.Value\n echo \"$template\"\n }\n\n # Execute the pre-defined build step. Note the `msbuildArgs` variable.\n - task: VSBuild@1\n inputs:\n solution: '**/*.sln'\n msbuildArgs: /p:OutDir=$(Build.ArtifactStagingDirectory)\n platform: Any CPU\n configuration: Release\n # Execute a clean build, in order to remove any existing build artifacts prior to the build.\n clean: True\n displayName: Visual Studio Build\n\n # Read and set the generated environment variables to end build tracing. This is done in PowerShell in this example.\n - task: PowerShell@1\n displayName: Clear CodeQL environment variables\n inputs:\n targetType: inline\n script: >\n $json = Get-Content $(System.DefaultWorkingDirectory)/db/temp/tracingEnvironment/end-tracing.json | ConvertFrom-Json\n $json.PSObject.Properties | ForEach-Object {\n $template = \"##vso[task.setvariable variable=\"\n $template += $_.Name\n $template += \"]\"\n $template += $_.Value\n echo \"$template\"\n }\n\n - task: CmdLine@2\n displayName: Finalize CodeQL database\n inputs:\n script: 'codeql database finalize db'\n\n # Other tasks go here, for example:\n # `codeql database analyze`\n # then `codeql github upload-results` ...\n```\n\n## Étapes suivantes\n\n* Pour savoir comment utiliser les données CodeQL CLI pour analyser la base de données que vous avez créée à partir de votre code, consultez [Analyse de votre code avec des requêtes CodeQL](/fr/code-security/codeql-cli/getting-started-with-the-codeql-cli/analyzing-your-code-with-codeql-queries)."}