# Verificação de código do CodeQL para linguagens compiladas Entenda como CodeQL analisa idiomas compilados, as opções de build disponíveis e saiba como você pode personalizar o processo de geração de banco de dados, se necessário. ## Comparar modos de construção
| Característica do modo de compilação | Nenhum | Compilação automática | Manual | | ------------------------------------------------------------------------- | ---------------------------- | --------------------------------- | ----------------------- | | Usado pela configuração padrão e para habilitação em nível de organização | Sim (C/C++, C#, Java e Rust) | Sim, onde `none` não é compatível | No | | A análise é bem-sucedida sem a configuração do usuário | Sim | Variable | No | | Completude da análise | Código gerado não analisado | Variable | Controlado pelo usuário | | Precisão da análise | Bom | Bom | Best |
## Escolher um modo de build Quando você estiver configurando code scanning pela primeira vez ou em vários repositórios, é melhor usar a configuração padrão. A configuração padrão usa o método mais simples disponível para gerar um CodeQL banco de dados e analisar seu código, para que você possa começar a corrigir alertas assim que possível. Depois de resolver os alertas iniciais, convém alternar para a configuração avançada com um processo de compilação manual para repositórios de alto risco. Para obter comportamentos `autobuild` específicos da linguagem, requisitos do executor e detalhes do modo de compilação para linguagens compiladas, consulte [Opções e etapas de build do CodeQL para idiomas compilados](/pt/code-security/reference/code-scanning/codeql/codeql-build-options-and-steps-for-compiled-languages). ## Usar vários modos de build em um repositório de vários idiomas Para repositórios com várias linguagens compiladas, você pode usar diferentes modos de compilação para diferentes idiomas. Por exemplo, se o repositório contiver C/C++, C# e Java, convém fornecer etapas de build manuais para um idioma (aqui C/C++). Este fluxo de trabalho especifica um modo de compilação diferente para cada idioma. ```yaml strategy: matrix: include: # Analyzes C and C++ code using the commands in `Build C and C++ code` - language: c-cpp build-mode: manual # Analyzes C# code by automatically detecting a build - language: csharp build-mode: autobuild # Analyzes Java code directly from the codebase without a build - language: java-kotlin build-mode: none # analyzes Java only steps: - name: Checkout repository uses: actions/checkout@v5 # Initializes CodeQL tools and creates a codebase for analysis. - name: Initialize CodeQL uses: github/codeql-action/init@v4 with: languages: ${{ matrix.language }} - if: ${{ matrix.build-mode == 'manual' }} name: Build C and C++ code run: | echo 'If you are using a "manual" build mode for one or more of the' \ 'languages you are analyzing, replace this with the commands to build' \ 'your code, for example:' echo ' make bootstrap' echo ' make release' exit 1 ``` Para obter informações sobre os idiomas, bibliotecas e estruturas com suporte na versão mais recente, CodeQLconsulte [linguagens e estruturas com suporte](https://codeql.github.com/docs/codeql-overview/supported-languages-and-frameworks) na CodeQL documentação. Para obter informações sobre os requisitos do sistema para executar a versão mais recente, CodeQLconsulte [os requisitos](https://codeql.github.com/docs/codeql-overview/system-requirements/#additional-software-requirements) do CodeQL sistema na documentação. ## Habilitar o cache de dependência para CodeQL Para os fluxos de trabalho de configuração padrão, o cache de dependência é habilitado apenas para GitHubexecutores hospedados em repositórios públicos e privados. Para fluxos de trabalho de configuração avançada, o cache de dependências está desativado por padrão. Para habilitar o cache de dependência CodeQL, utilize a configuração `dependency-caching` para a ação CodeQL em seu fluxo de trabalho de configuração avançada. Esta configuração aceita os seguintes valores: * `false` / `none` / `off`: o cache de dependências está desativado (padrão). * `restore`: restaure apenas os caches existentes, não armazene novos caches. * `store`: armazene apenas novos caches, não restaure caches existentes. * `true` / `full` / `on`: restaurar caches existentes e armazenar novos caches. Por exemplo, as seguintes configurações habilitariam o cache de dependência para a ação CodeQL : ```yaml # Initializes CodeQL with dependency caching enabled - name: Initialize CodeQL uses: github/codeql-action/init@v4 with: languages: java dependency-caching: true ``` ## Usar o `none` modo de compilação para CodeQL Para C/C++, C#, Java e Rust, CodeQL cria um banco de dados sem exigir um build ao habilitar a configuração padrão para code scanning a menos que o repositório também inclua código Kotlin. Se um repositório contiver código Kotlin além de código Java, a configuração padrão é habilitada com o processo de construção automática porque a análise de Kotlin exigirá uma construção. A criação de um CodeQL banco de dados sem um build poderá produzir resultados menos precisos do que usar `autobuild` ou etapas manuais de build se: * Os scripts de compilação não podem ser consultados para obter informações de dependência, e as suposições de dependência são imprecisas. * O repositório normalmente gera código durante o processo de compilação. Para usar o `autobuild` ou etapas de compilação manuais, é possível usar a configuração avançada. > \[!NOTE] Para Java análise, se `build-mode` estiver definido como `none` e o código Kotlin for encontrado no repositório, o código Kotlin não será analisado e um aviso será produzido. Consulte [Opções e etapas de build do CodeQL para idiomas compilados](/pt/code-security/reference/code-scanning/codeql/codeql-build-options-and-steps-for-compiled-languages#building-java-and-kotlin). ## Use `autobuild` para CodeQL A ação CodeQL usa o `autobuild` para analisar linguagens compiladas nos seguintes casos. * A configuração padrão está habilitada e o idioma não suporta a compilação `none` (com suporte para C/C++, C#, Java e Rust). * A configuração avançada está habilitada e o fluxo de trabalho especifica `build-mode: autobuild`. * A configuração avançada está habilitada e o fluxo de trabalho tem uma etapa de compilação automática para o idioma usando a ação `autobuild` (`github/codeql-action/autobuild@v4`). ### Use a opção `build-mode` ```yaml # Initializes the CodeQL tools for scanning. name: Analyze strategy: matrix: include: # Analyze C and C++ code - language: c-cpp build-mode: autobuild # Analyze Go code - language: go build-mode: autobuild steps: - uses: github/codeql-action/init@v4 with: languages: ${{ matrix.language }} build-mode: ${{ matrix.build-mode }} ``` ### Usar a etapa de Compilação Automática ```yaml # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL uses: github/codeql-action/init@v4 with: languages: ${{ matrix.language }} - name: Autobuild uses: github/codeql-action/autobuild@v4 ``` ## Especificar as etapas de compilação manualmente Você só pode especificar etapas de compilação manual se tiver ativado a configuração avançada. Consulte \[link para a documentação]. [Como definir a configuração avançada para verificação de código](/pt/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/configuring-advanced-setup-for-code-scanning#configuring-advanced-setup-for-a-repository). Se `autobuild` falhar ou se você quiser analisar um conjunto diferente de arquivos de origem daqueles criados pelo processo `autobuild`, será necessário fazer o seguinte: * Se o fluxo de trabalho especificar um modo de compilação para a linguagem, altere o modo de compilação para `manual`. * Se o fluxo de trabalho contiver uma etapa de `autobuild`, remova ou comente a etapa de `autobuild` no fluxo de trabalho. Em seguida, descompacte a etapa `run` e especifique manualmente o processo de build a ser usado. Para C/C++, C#, Go, Java, Kotlin e Swift, CodeQL analisará todo o código-fonte gerado pelas etapas de compilação especificadas. Atualize o fluxo de trabalho para definir `build-mode` como `manual`. ```yaml # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL - uses: github/codeql-action/init@v4 with: languages: ${{ matrix.language }} build-mode: manual - uses: github/codeql-action/analyze@v4 with: category: "/language:${{ matrix.language }}" ``` Como alternativa, atualize seu fluxo de trabalho para comentar a etapa “compilação automática”. ```yaml # Autobuild attempts to build any compiled languages. # - name: Autobuild # uses: github/codeql-action/autobuild@v4 ``` ### Adicionar comandos de build Quando a compilação manual estiver ativada, remova o comentário da etapa `run` no fluxo de trabalho e adicione comandos de compilação adequados ao seu repositório. A etapa `run` executa programas de linha de comando usando o shell do sistema operacional. Você pode modificar esses comandos e adicionar mais comandos para personalizar o processo de compilação. ```yaml - run: | make bootstrap make release ``` Para obter mais informações sobre a palavra-chave `run`, confira [Sintaxe de fluxo de trabalho para o GitHub Actions](/pt/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun). Se você adicionou etapas manuais no processo de build para linguagens compiladas e code scanning ainda não está funcionando no repositório, entre em contato conosco por meio do [Portal de suporte do GitHub](https://support.github.com).