{"meta":{"title":"Preparación del código para el análisis de CodeQL","intro":"Puede crear una CodeQL base de datos que contenga los datos necesarios para analizar el código.","product":"Seguridad y calidad del código","breadcrumbs":[{"href":"/es/code-security","title":"Seguridad y calidad del código"},{"href":"/es/code-security/tutorials","title":"Tutorials"},{"href":"/es/code-security/tutorials/customize-code-scanning","title":"Personalización del examen de código"},{"href":"/es/code-security/tutorials/customize-code-scanning/prepare-code-for-analysis","title":"Preparación del código para el análisis"}],"documentType":"article"},"body":"# Preparación del código para el análisis de CodeQL\n\nPuede crear una CodeQL base de datos que contenga los datos necesarios para analizar el código.\n\n\n\n## Acerca de la preparación del código para el análisis\n\nAntes de analizar el código mediante CodeQL, debe crear una CodeQL base de datos que contenga todos los datos necesarios para ejecutar consultas en el código. Puede crear usted mismo bases de datos CodeQL usando CodeQL CLI.\n\nCodeQL el análisis se basa en la extracción de datos relacionales del código y su uso para compilar una [CodeQL base de datos](https://codeql.github.com/docs/codeql-overview/codeql-glossary/#codeql-database).\nCodeQL Las bases de datos contienen toda la información importante sobre un código base, que se puede analizar mediante la ejecución de CodeQL consultas en él.\n\nAntes de generar una CodeQL base de datos, debe:\n\n1. Instale y configure el CodeQL CLI. Para obtener más información, vea [Configuración de la CLI de CodeQL](/es/code-security/codeql-cli/getting-started-with-the-codeql-cli/setting-up-the-codeql-cli).\n2. Extraiga del repositorio el código que quiera analizar:\n * En el caso de una rama, extraiga del repositorio el inicio de la rama que quiera analizar.\n * Para una solicitud de incorporación de cambios, extraiga del repositorio la confirmación principal o bien una confirmación de combinación generada por GitHub.\n3. Configure el entorno para el código base y asegúrese de que las dependencias estén disponibles.\n4. Para obtener los mejores resultados con lenguajes compilados, busque el comando build, si existe, para el código base. Normalmente está disponible en un archivo de configuración en el sistema de CI.\n\nUna vez que el código base esté listo, puedes ejecutar `codeql database create` para crear la base de datos. Para obtener más información, consulte [Creación de bases de datos para lenguajes no compilados](#creating-databases-for-non-compiled-languages) y [Creación de bases de datos para lenguajes compilados](#creating-databases-for-compiled-languages).\n\n## En ejecución `codeql database create`\n\nLas bases de datos de CodeQL se crean mediante la ejecución del siguiente comando desde la raíz de extracción del proyecto:\n\n```shell\ncodeql database create --language=\n```\n\nDebe especificar:\n\n* ``: una ruta de acceso a la base de datos nueva que se va a crear. Este directorio se creará al ejecutar el comando; no se puede especificar un directorio existente.\n* `--language`: el identificador del lenguaje para el que se va a crear una base de datos. Cuando se usa con `--db-cluster`, la opción acepta una lista separada por comas o se puede especificar más de una vez.\n CodeQL admite la creación de bases de datos para los siguientes idiomas:\n\n | Lenguaje | Identificador | Identificadores alternativos opcionales (si los hay) |\n | ----------------------------------- | ----------------------- | ---------------------------------------------------- |\n | C/C++ | `c-cpp` | |\n | `c` o `cpp` | | |\n | C# | `csharp` | |\n | | | |\n | Flujos de trabajo de GitHub Actions | `actions` | |\n | | | |\n | Go | `go` | |\n | Java/Kotlin | `java-kotlin` | |\n | `java` o `kotlin` | | |\n | JavaScript/TypeScript | `javascript-typescript` | |\n | `javascript` o `typescript` | | |\n | Python | `python` | |\n | Ruby | `ruby` | |\n | | | |\n | Rust | `rust` | |\n | | | |\n | Swift | `swift` | |\n\n > \\[!NOTE]\n > Si especificas uno de los identificadores alternativos, esto equivale a usar el identificador de idioma estándar. Por ejemplo, especificar `javascript` en lugar de `javascript-typescript` no excluirá el análisis del código TypeScript. En su lugar, puedes usar la opción `--codescanning-config` CLI para cargar un archivo de configuración que especifique los archivos que se excluirán con la clave de configuración `paths-ignore`. Consulte [Opciones de configuración de flujo de trabajo para el examen de código](/es/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning#custom-configuration-files).\n >\n > Como alternativa, para los lenguajes que lo admiten, usa un comando de compilación personalizado que solo compile los archivos que deseas examinar. Consulta [Creación de bases de datos para lenguajes compilados](/es/code-security/codeql-cli/getting-started-with-the-codeql-cli/preparing-your-code-for-codeql-analysis#creating-databases-for-compiled-languages).\n\nSi el código base tiene un comando de compilación o un script que invoca el proceso de compilación, se recomienda especificarlo también:\n\n```shell\n codeql database create --command \\\n --language=\n```\n\n### Opciones para crear bases de datos\n\nPuede especificar opciones adicionales en función de la ubicación del archivo de origen, si es necesario compilar el código y si desea crear CodeQL bases de datos para más de un idioma.\n\n| Opción | Obligatorio | Uso |\n| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `` | | Especifique el nombre y la ubicación de un directorio que se va a crear para la CodeQL base de datos. Se producirá un error en el comando si intenta sobrescribir un directorio existente. Si también especifica `--db-cluster`, este es el directorio primario y se crea un subdirectorio para cada lenguaje analizado. |\n| --language | | Especifique el identificador del idioma para el que se va a crear una base de datos, una de las siguientes: `c-cpp`, `csharp`, `go`, `java-kotlin`, `javascript-typescript`, `python``ruby`, `rust` y `swift`. Cuando se usa con --db-cluster, la opción acepta una lista separada por comas o se puede especificar más de una vez. |\n| --command | | |\n| **Opción recomendada.** Se usa para especificar el comando de compilación o el script que invoca el proceso de compilación para el código base. Los comandos se ejecutan desde la carpeta actual o, donde se define, desde --source-root. No es necesario para el análisis de Python y JavaScript o TypeScript. | | |\n| --build-mode | | |\n| **Opción recomendada.** Se utiliza con C/C++, C#, Java y Rust cuando no se proporciona un `--command` para especificar si se debe crear una base de datos de CodeQL sin una compilación (`none`) o intentando detectar automáticamente un comando de compilación (`autobuild`). De forma predeterminada, se usa la detección de Autobuild. Para obtener una comparación de los modos de compilación, consulta [Modos de compilación de CodeQL](/es/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages#codeql-build-modes). | | |\n| --db-cluster | | Se usa en códigos base de varios lenguajes para generar una base de datos para cada lenguaje especificado por --language. |\n| --no-run-unnecessary-builds | | |\n| **Opción recomendada.** Use para suprimir el comando de compilación para los lenguajes en los que el CodeQL CLI no necesita supervisar la compilación (por ejemplo, Python y JavaScript/TypeScript). | | |\n| --source-root | | Se usa si ejecuta la CLI fuera de la raíz de extracción del repositorio. De manera predeterminada, el comando `database create` supone que el directorio actual es el directorio raíz de los archivos de origen. Use esta opción para especificar otra ubicación. |\n| --codescanning-config | | Avanzado. Úselo si tiene un archivo de configuración que especifica cómo crear las bases de datos CodeQL y qué consultas ejecutar en los pasos posteriores. Para obtener más información, vea [Opciones de configuración de flujo de trabajo para el examen de código](/es/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning#custom-configuration-files) y [creación de base de datos](/es/code-security/codeql-cli/codeql-cli-manual/database-create#--codescanning-configfile). |\n\nPuede especificar opciones de extractor para personalizar el comportamiento de los extractores que crean CodeQL bases de datos. Para obtener más información, vea [Opciones de extractor](/es/code-security/codeql-cli/using-the-advanced-functionality-of-the-codeql-cli/extractor-options).\n\nPara obtener información detallada sobre todas las opciones que se pueden usar al crear bases de datos, consulte [creación de base de datos](/es/code-security/codeql-cli/codeql-cli-manual/database-create).\n\n### Ejemplo de un solo lenguaje\n\nEn este ejemplo se crea una única base de datos CodeQL para el repositorio extraído en `/checkouts/example-repo`. Usa el extractor de JavaScript para crear una representación jerárquica del código JavaScript y TypeScript en el repositorio. La base de datos resultante se almacena en `/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### Ejemplo de lenguaje múltiple\n\nEn este ejemplo se crean dos bases de datos CodeQL para el repositorio extraído en `/checkouts/example-repo-multi`. Utiliza:\n\n* `--db-cluster` para solicitar el análisis de más de un lenguaje.\n* `--language` para especificar los lenguajes para los que se crearán las bases de datos.\n* `--command` para indicarle a la herramienta el comando de compilación para el código base, en este caso `make`.\n* `--no-run-unnecessary-builds` para indicar a la herramienta que omita el comando de compilación de los lenguajes en los que no sea necesario (como Python).\n\nLas bases de datos resultantes se almacenan en los subdirectorios `python` y `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## Progreso y resultados\n\nLos errores se notifican si hay algún problema con las opciones especificadas. En el caso de los idiomas interpretados y cuando se especifica `--build-mode none` para C/C++, C#, Java y Rust, el progreso de la extracción se muestra en la consola. Para cada archivo de origen, la consola muestra si la extracción se realizó correctamente o si se produjo un error. En el caso de los lenguajes compilados, la consola mostrará la salida del sistema de compilación.\n\nCuando la base de datos se crea correctamente, encontrarás un directorio nuevo en la ruta de acceso especificada en el comando. Si usaste la opción `--db-cluster` para crear más de una base de datos, se crea un subdirectorio para cada lenguaje. Cada CodeQL directorio de base de datos contiene varios subdirectorios, incluidos los datos relacionales (necesarios para el análisis) y un archivo de origen, una copia de los archivos de origen realizados en el momento en que se creó la base de datos, que se usa para mostrar los resultados del análisis.\n\n## Creación de bases de datos para lenguajes no compilados\n\nEl CodeQL CLI incluye extractores para crear bases de datos para lenguajes no compilados, específicamente JavaScript (y TypeScript), Python y Ruby. Estos extractores se invocan automáticamente al especificar JavaScript, Python o Ruby como la opción `--language` al ejecutar `database create`. Al crear bases de datos para estos lenguajes, debes asegurarte de que todas las dependencias adicionales están disponibles.\n\n> \\[!NOTE]\n> Al ejecutar `database create` para JavaScript, TypeScript, Python y Ruby, no debe especificar una opción `--command`. De lo contrario, invalidará la invocación de extractor normal, que creará una base de datos vacía. Si creas bases de datos para varios lenguajes y uno de ellos es un lenguaje compilado, usa la opción `--no-run-unnecessary-builds` a fin de omitir el comando de los lenguajes que no sea necesario compilar.\n\n### JavaScript y TypeScript\n\nLa creación de bases de datos para JavaScript no requiere dependencias adicionales, pero si el proyecto incluye archivos TypeScript, debes instalar Node.js 14 o una versión posterior que debe estar disponible en `PATH` como `node`. En la línea de comandos, puedes especificar `--language=javascript-typescript` para extraer archivos JavaScript y TypeScript:\n\n```shell\ncodeql database create --language=javascript-typescript --source-root /javascript-database\n```\n\nAquí hemos especificado una ruta de acceso `--source-root`, que es la ubicación donde se ejecuta la creación de la base de datos, pero no es necesariamente la raíz de restauración del código base.\n\nDe manera predeterminada, los archivos de los directorios `node_modules` y `bower_components` no se extraen.\n\n### Python\n\nAl crear bases de datos para Python debe asegurarse de lo siguiente:\n\n* Tiene Python 3 instalado y accesible para el extractor CodeQL.\n* Tiene instalada la versión de Python usada por su código.\n\nEn la línea de comandos, debes especificar `--language=python`. Por ejemplo:\n\n```shell\ncodeql database create --language=python /python-database\n```\n\nEsto ejecuta el subcomando `database create` desde la raíz de restauración del código, lo que genera una base de datos de Python nueva en `/python-database`.\n\n### Ruby\n\nLa creación de bases de datos para Ruby no requiere dependencias adicionales. En la línea de comandos, debes especificar `--language=ruby`. Por ejemplo:\n\n```shell\ncodeql database create --language=ruby --source-root /ruby-database\n```\n\nAquí hemos especificado una ruta de acceso `--source-root`, que es la ubicación donde se ejecuta la creación de la base de datos, pero no es necesariamente la raíz de restauración del código base.\n\n## Creación de bases de datos para lenguajes compilados\n\nPara la mayoría de los lenguajes compilados, CodeQL debe invocar el sistema de compilación necesario para generar una base de datos, por lo que el método de compilación debe estar disponible para la CLI. Este enfoque crea bases de datos que incluyen código generado.\nCodeQL tiene dos métodos para compilar código base:\n\n* [Detección automática de compilaciones (generación automática)](#automatically-detecting-the-build-system)\n* [Comandos de compilación especificados por el usuario](/es/code-security/codeql-cli/getting-started-with-the-codeql-cli/preparing-your-code-for-codeql-analysis#specifying-build-commands)\n\nAdemás, para C/C++, C#, Java y Rust, hay una opción para generar una base de datos sin compilar el código. Esto resulta especialmente útil cuando se desea habilitar code scanning para muchos repositorios. Para más información, consulta [Modos de compilación de CodeQL](/es/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages#codeql-build-modes).\n\n### Detección automática del sistema de compilación\n\nCodeQL CLI incluye compiladores automáticos para código C/C++, C#, Go, Java, Kotlin y Swift.\nCodeQL Los autobuilders permiten compilar proyectos para lenguajes compilados sin especificar comandos de compilación. Cuando se invoca un autobuilder, CodeQL examina el origen de la evidencia de un sistema de compilación e intenta ejecutar el conjunto óptimo de comandos necesarios para extraer una base de datos. Para obtener más información, vea [CodeQL code scanning for compiled languages](/es/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages#about-autobuild).\n\nUn compilador automático se invoca automáticamente cuando se ejecuta `codeql database create` para un lenguaje compilado si no incluyes una opción `--command` o estableces `--build-mode none`. Por ejemplo, para un código base en Swift, puedes ejecutar simplemente:\n\n```shell\ncodeql database create --language=swift /swift-database\n```\n\nSi un código base usa un sistema de compilación estándar, basarse en un generador automático suele ser la manera más sencilla de crear una base de datos. En el caso de los orígenes que requieren pasos de compilación que no son estándar, es posible que tengas que definir de forma explícita cada paso en la línea de comandos.\n\n> \\[!NOTE]\n>\n> * Si vas a compilar una base de datos de Go, instala la cadena de herramientas de Go (versión 1.11 o una posterior) y, si hay dependencias, el administrador de dependencias adecuado (por ejemplo, [dep](https://golang.github.io/dep/)).\n> * El generador automático de Go intenta detectar automáticamente el código escrito en Go en un repositorio y solo ejecuta scripts de compilación en un intento de capturar dependencias. Para forzar CodeQL a limitar la extracción a los archivos compilados por el script de compilación, establezca la variable `CODEQL_EXTRACTOR_GO_BUILD_TRACING=on` de entorno o use la `--command` opción para especificar un comando de compilación.\n\n### Especificación de comandos de compilación\n\nLos ejemplos siguientes están pensados para darte una idea de algunos de los comandos de compilación que puedes especificar para los lenguajes compilados.\n\n> \\[!NOTE]\n> La opción `--command` acepta un único argumento; si necesita usar más de un comando, especifique `--command` varias veces. Si necesitas pasar subcomandos y opciones, el argumento entero debe ir entre comillas para que se interprete correctamente.\n\n* Proyecto de C/C++ compilado con `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* Proyecto de C# compilado con `dotnet build`:\n\n Es recomendable agregar `/t:rebuild` para asegurarse de que se compilará todo el código o haga un anterior `dotnet clean` (el código que no está compilado no se incluirá en la CodeQL base de datos):\n\n ```shell\n codeql database create csharp-database --language=csharp --command='dotnet build /t:rebuild'\n ```\n\n* Ve al proyecto compilado con la variable de entorno `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* Ve al proyecto compilado con un script de compilación personalizado:\n\n ```shell\n codeql database create go-database --language=go --command='./scripts/build.sh'\n ```\n\n* Java proyecto creado con 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* Java proyecto creado con Maven:\n\n ```shell\n codeql database create java-database --language=java-kotlin --command='mvn clean install'\n ```\n\n* Java proyecto creado con Ant:\n\n ```shell\n codeql database create java-database --language=java-kotlin --command='ant -f build.xml'\n ```\n\n* Proyecto de Rust creado mediante Cargo:\n\n ```shell\n codeql database create rust-database --language=rust\n ```\n\n* Proyecto de Swift compilado con un proyecto o área de trabajo de Xcode. De forma predeterminada, se compila el destino de Swift más grande:\n\n Es una buena idea asegurarse de que el proyecto está en un estado limpio y de que no hay artefactos de compilación disponibles.\n\n ```shell\n xcodebuild clean -all\n codeql database create -l swift swift-database\n ```\n\n* Proyecto de Swift compilado con `swift build`:\n\n ```shell\n codeql database create -l swift -c \"swift build\" swift-database\n ```\n\n* Proyecto de Swift compilado con `xcodebuild`:\n\n ```shell\n codeql database create -l swift -c \"xcodebuild build -target your-target\" swift-database\n ```\n\n Puedes pasar las opciones `archive` y `test` a `xcodebuild`. Sin embargo, se recomienda el comando estándar `xcodebuild` , ya que debe ser el más rápido y debe ser todo lo que CodeQL requiere para un examen correcto.\n\n* Proyecto de Swift compilado con un script de compilación personalizado:\n\n ```shell\n codeql database create -l swift -c \"./scripts/build.sh\" swift-database\n ```\n\n* Proyecto compilado con 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> Actualmente, la compilación de Bazel para Go no se admite.\n\n* Proyecto compilado con un script de compilación personalizado:\n\n ```shell\n codeql database create new-database --language= --command='./scripts/build.sh'\n ```\n\nEste comando ejecuta un script personalizado que contiene todos los comandos necesarios para compilar el proyecto.\n\n\n\n\n\n### Uso del seguimiento indirecto de la compilación\n\nSi los generadores automáticos CodeQL CLI para lenguajes compilados no funcionan con su flujo de trabajo de CI y no puede envolver las invocaciones de comandos de compilación con `codeql database trace-command`, puede usar el trazado indirecto de compilación para crear una base de datos CodeQL. A fin de usar el seguimiento indirecto de la compilación, el sistema de CI debe poder establecer variables de entorno personalizadas para cada acción de compilación.\n\nPara crear una base de datos de CodeQL con seguimiento indirecto de compilación, ejecute el siguiente comando desde la raíz de desprotección del proyecto:\n\n```shell\ncodeql database init ... --begin-tracing \n```\n\nDebe especificar:\n\n* ``: una ruta de acceso a la base de datos nueva que se va a crear. Este directorio se creará al ejecutar el comando; no se puede especificar un directorio existente.\n* `--begin-tracing`: crea scripts que se pueden usar para configurar un entorno en el que se realizará un seguimiento de los comandos de compilación.\n\nPuedes especificar otras opciones para el comando `codeql database init` con normalidad.\n\n> \\[!NOTE]\n> Si la compilación se ejecuta en Windows, debe establecer `--trace-process-level ` o `--trace-process-name ` para que la opción apunte a un proceso de CI primario que observará todos los pasos de compilación para el código que se está analizando.\n\nEl comando `codeql database init` dará generará un mensaje:\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\nEl `codeql database init` comando crea `/temp/tracingEnvironment` con archivos que contienen variables de entorno y valores que permitirán CodeQL realizar un seguimiento de una secuencia de pasos de compilación. Estos archivos se denominan `start-tracing.{json,sh,bat,ps1}`. Usa uno de estos archivos con el mecanismo del sistema de CI a fin de establecer variables de entorno para pasos futuros. Ustedes pueden:\n\n* Leer el archivo JSON, procesarlo e imprimir variables de entorno en el formato que espera el sistema de CI. Por ejemplo, Azure DevOps espera `echo \"##vso[task.setvariable variable=NAME]VALUE\"`.\n* O bien, si el sistema de CI conserva el entorno, obtén el script de `start-tracing` adecuado para establecer las variables de CodeQL en el entorno de shell del sistema de CI.\n\nCompila el código; opcionalmente, anula las variables de entorno mediante un script de `end-tracing.{json,sh,bat,ps1}` del directorio donde se almacenan los scripts de `start-tracing`; y, después, ejecuta el comando `codeql database finalize `.\n\nUna vez que haya creado una CodeQL base de datos mediante el seguimiento indirecto de la compilación, puede trabajar con ella como cualquier otra CodeQL base de datos. Por ejemplo, analice la base de datos y cargue los resultados en GitHub si utiliza el análisis de código.\n\n### Ejemplo de creación de una CodeQL base de datos mediante el seguimiento indirecto de compilación\n\n> \\[!NOTE]\n> Si usa canalizaciones de Azure DevOps, la manera más sencilla de crear una base de datos CodeQL es usar GitHub Advanced Security for Azure DevOps. Para obtener documentación, consulte [Configure GitHub Advanced Security for Azure DevOps](https://learn.microsoft.com/en-us/azure/devops/repos/security/configure-github-advanced-security-features) en Microsoft Learn.\n\nEn el ejemplo siguiente se muestra cómo puede usar el seguimiento indirecto de compilación en una canalización de Azure DevOps para crear una base de datos 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## Pasos siguientes\n\n* Para obtener información sobre cómo usar CodeQL CLI para analizar la base de datos que creó a partir del código, consulte [Análisis del código con consultas de CodeQL](/es/code-security/codeql-cli/getting-started-with-the-codeql-cli/analyzing-your-code-with-codeql-queries)."}