As inscrições para a BazelCon 2024 já estão abertas.

Esta página foi traduzida pela API Cloud Translation.

Como usar o Bazel no Windows

7.3 · 7.2 · 7.1 · 7.0 · 6.5

Nesta página, você verá as práticas recomendadas para usar o Bazel no Windows. Para instruções de instalação, consulte Instalar o Bazel no Windows.

Problemas conhecidos

Os problemas do Bazel relacionados ao Windows são marcados com o rótulo "team-Windows" no GitHub. Confira os problemas em aberto aqui.

Práticas recomendadas

Evitar problemas de caminho longo

Algumas ferramentas têm a limitação máxima do tamanho do caminho no Windows, incluindo o compilador MSVC. Para evitar esse problema, especifique um diretório de saída curto para o Bazel usando a flag --output_user_root.

Por exemplo, adicione a seguinte linha ao arquivo bazelrc:

startup --output_user_root=C:/tmp

Ativar o suporte a nomes de arquivos 8.3

O Bazel tenta criar uma versão de nome curto para caminhos de arquivo longos. No entanto, para isso, o suporte a nomes de arquivos 8.3 precisa ser ativado para o volume em que o arquivo com o caminho longo está localizado. Para ativar a criação de nomes 8.3 em todos os volumes, execute o seguinte comando:

fsutil 8dot3name set 0

Ativar o suporte a links simbólicos

Alguns recursos exigem que o Bazel possa criar links simbólicos de arquivos no Windows, ativando o Modo de desenvolvedor (no Windows 10 versão 1703 ou mais recente) ou executando o Bazel como administrador. Isso ativa os seguintes recursos:

Para facilitar, adicione as seguintes linhas ao arquivo bazelrc:

startup --windows_enable_symlinks
build --enable_runfiles

Observação: a criação de links simbólicos no Windows é uma operação dispendiosa. A flag --enable_runfiles pode criar uma grande quantidade de links simbólicos de arquivo. Ative esse recurso apenas quando precisar.

Execução do Bazel: shell MSYS2 x prompt de comando x PowerShell

Recomendação:execute o Bazel no prompt de comando (cmd.exe) ou no PowerShell.

A partir de 2020-01-15, não execute o Bazel em bash, seja no shell MSYS2, no Git Bash, no Cygwin ou em qualquer outra variante do Bash. Embora o Bazel possa funcionar para a maioria dos casos de uso, algumas coisas estão corrompidas, como interromper o build com Ctrl+C no MSYS2. Além disso, se você optar por executar no MSYS2, precisará desativar a conversão automática de caminho do MSYS2. Caso contrário, o MSYS converterá argumentos de linha de comando que parecem caminhos Unix (como //foo:bar) em caminhos do Windows. Consulte esta resposta do StackOverflow para mais detalhes.

Como usar o Bazel sem o Bash (MSYS2)

Como usar o build do Bazel sem Bash

As versões do Bazel anteriores à 1.0 costumavam exigir que o Bash criasse algumas regras.

A partir do Bazel 1.0, é possível criar qualquer regra sem o Bash, a menos que seja:

genrule, porque as regras gerais executam comandos Bash
a regra sh_binary ou sh_test, porque elas precisam de Bash inerentemente.
Regra do Starlark que usa ctx.actions.run_shell() ou ctx.resolve_command()

No entanto, genrule é usado com frequência para tarefas simples, como copiar um arquivo ou gravar um arquivo de texto. Em vez de usar genrule (e dependendo do Bash), você pode encontrar uma regra adequada no repositório bazel-skylib. Quando criadas no Windows, essas regras não exigem o Bash.

Como usar o teste do Bazel sem o Bash

As versões do Bazel anteriores à 1.0 costumavam exigir o Bash para executar bazel test em qualquer coisa.

A partir do Bazel 1.0, é possível testar qualquer regra sem o Bash, exceto quando:

você usar --run_under;
a própria regra de teste exige Bash (porque o executável é um script de shell).

Como usar a execução do Bazel sem Bash

As versões do Bazel anteriores à 1.0 exigiam que o Bash bazel run algo.

A partir do Bazel 1.0, é possível executar qualquer regra sem o Bash, exceto quando:

você usa --run_under ou --script_path
a própria regra de teste exige Bash (porque o executável é um script de shell).

Uso das regras sh_binary e sh_* e ctx.actions.run_shell() sem Bash

Você precisa do Bash para criar e testar regras de sh_* e para criar e testar regras do Starlark que usam ctx.actions.run_shell() e ctx.resolve_command(). Isso se aplica não apenas às regras do seu projeto, mas também às regras de qualquer um dos repositórios externos de que o projeto depende (mesmo transitivamente).

No futuro, talvez haja uma opção de usar o Subsistema Windows para Linux (WSL) para criar essas regras, mas, no momento, isso não é uma prioridade para a subequipe do Bazel no Windows.

Como definir variáveis de ambiente

As variáveis de ambiente definidas no prompt de comando do Windows (cmd.exe) são definidas apenas nessa sessão do prompt de comando. Se você iniciar um novo cmd.exe, vai precisar definir as variáveis novamente. Para sempre definir as variáveis quando cmd.exe for iniciado, adicione-as às variáveis do usuário ou do sistema na caixa de diálogo Control Panel > System Properties > Advanced > Environment Variables....

Criar no Windows

Criar C++ com MSVC

Para criar destinos C++ com o MSVC, você precisa:

O compilador do Visual C++.
(Opcional) A variável de ambiente BAZEL_VC e BAZEL_VC_FULL_VERSION.

O Bazel detecta automaticamente o compilador do Visual C++ no seu sistema. Para informar ao Bazel que ele deve usar uma instalação de VC específica, defina as seguintes variáveis de ambiente:

Para o Visual Studio 2017 e 2019, defina uma das opções BAZEL_VC. Além disso, também é possível definir BAZEL_VC_FULL_VERSION.
- BAZEL_VC o diretório de instalação das Ferramentas de build do Visual C++
```
set BAZEL_VC=C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC
```
- BAZEL_VC_FULL_VERSION (opcional) Somente para o Visual Studio 2017 e 2019, o número da versão completa das ferramentas de build do Visual C++. Você pode escolher a versão exata das ferramentas de build do Visual C++ via BAZEL_VC_FULL_VERSION se mais de uma versão estiver instalada. Caso contrário, o Bazel vai escolher a mais recente.
```
set BAZEL_VC_FULL_VERSION=14.16.27023
```
Para o Visual Studio 2015 ou versões anteriores, defina BAZEL_VC. BAZEL_VC_FULL_VERSION não é compatível.
- BAZEL_VC o diretório de instalação das Ferramentas de build do Visual C++
```
set BAZEL_VC=C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC
```
O SDK do Windows.

O SDK do Windows contém arquivos de cabeçalho e bibliotecas necessárias para criar aplicativos Windows, incluindo o próprio Bazel. Por padrão, o SDK mais recente do Windows instalado será usado. Também é possível especificar a versão do SDK do Windows definindo BAZEL_WINSDK_FULL_VERSION. Você pode usar um número completo do SDK do Windows 10, como 10.0.10240.0, ou especificar 8.1 para usar o SDK do Windows 8.1 (apenas uma versão do SDK do Windows 8.1 está disponível). Verifique se você tem o SDK do Windows especificado instalado.

Requisito: isso é compatível com o VC 2017 e 2019. As ferramentas de build do VC 2015 independentes não oferecem suporte à seleção do SDK do Windows. Você precisará da instalação completa do Visual Studio 2015. Caso contrário, BAZEL_WINSDK_FULL_VERSION será ignorado.
```
set BAZEL_WINSDK_FULL_VERSION=10.0.10240.0
```

Se tudo estiver configurado, você poderá criar um destino C++ agora.

Tente criar um destino usando um dos nossos projetos de exemplo:

bazel build //examples/cpp:hello-world
bazel-bin\examples\cpp\hello-world.exe

Por padrão, os binários criados são voltados à arquitetura x64. Para especificar uma arquitetura de destino diferente, defina a opção de build --cpu para a arquitetura de destino: * x64 (padrão): --cpu=x64_windows ou nenhuma opção * x86: --cpu=x64_x86_windows * ARM: --cpu=x64_arm_windows * ARM64: --cpu=arm64_windows

Por exemplo, para criar destinos para a arquitetura ARM, execute:

bazel build //examples/cpp:hello-world --cpu=x64_arm_windows

Para criar e usar bibliotecas dinamicamente vinculadas (arquivos DLL), consulte este exemplo.

Limite de comprimento da linha de comando: para evitar o problema de limite de comprimento da linha de comando do Windows, ative o recurso de arquivo de parâmetro do compilador usando --features=compiler_param_file.

Criar C++ com Clang

A partir da versão 0.29.0, o Bazel oferece suporte à criação com o driver de compilador compatível com MSVC do LLVM (clang-cl.exe).

Requisito: para criar com o Clang, é necessário instalar ambas LLVM e do Visual C++. Mesmo que você use o clang-cl.exe como compilador, ainda é necessário vincular as bibliotecas do Visual C++.

O Bazel pode detectar automaticamente a instalação do LLVM no seu sistema ou você pode informar explicitamente ao Bazel onde o LLVM está instalado usando BAZEL_LLVM.

BAZEL_LLVM: o diretório de instalação do LLVM.
```
set BAZEL_LLVM=C:\Program Files\LLVM
```

Há várias situações para ativar a cadeia de ferramentas do Clang para criar C++.

No Bazel 0.28 e versões anteriores: o Clang não é compatível.
Sem --incompatible_enable_cc_toolchain_resolution: você pode ativar o conjunto de ferramentas do Clang por uma flag de build --compiler=clang-cl.
Com --incompatible_enable_cc_toolchain_resolution: é necessário adicionar um destino de plataforma ao BUILD file (por exemplo, o arquivo BUILD de nível superior):
```
platform(
    name = "x64_windows-clang-cl",
    constraint_values = [
        "@platforms//cpu:x86_64",
        "@platforms//os:windows",
        "@bazel_tools//tools/cpp:clang-cl",
    ],
)
```
Em seguida, ative a cadeia de ferramentas Clang de uma destas duas maneiras:
- Especifique as seguintes flags de build:
```
--extra_toolchains=@local_config_cc//:cc-toolchain-x64_windows-clang-cl --extra_execution_platforms=//:x64_windows-clang-cl
```
- Registre a plataforma e o conjunto de ferramentas no arquivo MODULE.bazel:
```
register_execution_platforms(
    ":x64_windows-clang-cl"
)

register_toolchains(
    "@local_config_cc//:cc-toolchain-x64_windows-clang-cl",
)
```
A flag --incompatible_enable_cc_toolchain_resolution será ativada por padrão em uma versão futura do Bazel. Portanto, é recomendável ativar o suporte ao Clang com a segunda abordagem.

Criar Java

Para criar destinos Java, você precisa:

O kit de desenvolvimento Java SE

No Windows, o Bazel cria dois arquivos de saída para regras java_binary:

um arquivo .jar
Um arquivo .exe que pode configurar o ambiente para a JVM e executar o binário

Tente criar um destino usando um dos nossos projetos de exemplo:

  bazel build //examples/java-native/src/main/java/com/example/myproject:hello-world
  bazel-bin\examples\java-native\src\main\java\com\example\myproject\hello-world.exe

Build Python

Para criar destinos do Python, você precisa de:

O interpretador do Python

No Windows, o Bazel cria dois arquivos de saída para regras py_binary:

um arquivo ZIP autoextraível
um arquivo executável que pode iniciar o interpretador Python com o arquivo zip autoextraível como argumento

Você pode executar o arquivo executável (que tem uma extensão .exe) ou executar o Python com o arquivo ZIP autoextraível como argumento.

Tente criar um destino usando um dos nossos projetos de exemplo:

  bazel build //examples/py_native:bin
  bazel-bin\examples\py_native\bin.exe
  python bazel-bin\examples\py_native\bin.zip

Se você tem interesse em detalhes sobre como o Bazel cria destinos do Python no Windows, confira este documento de design.