Como criar e testar o Rust

Introdução

Este guia mostra como criar, testar e publicar um pacote do Rust.

Executores hospedados em GitHub têm um cache de ferramentas com software pré-instalado que inclui dependências do Rust. Para ver a lista completa de programas de software atualizados e as versões pré-instaladas do Rust, confira Sobre executores hospedados no GitHub.

Pré-requisitos

Você já deve estar familiarizado com a sintaxe YAML e como é usado com GitHub Actions. Para saber mais, confira Sintaxe de fluxo de trabalho para o GitHub Actions.

Recomendamos que você tenha um entendimento básico da linguagem Rust. Para ver mais informações, confira Introdução ao Rust.

Como usar um modelo de fluxo de trabalho do Rust

Para uma introdução rápida, adicione um modelo de fluxo de trabalho ao diretório .github/workflows do repositório.

O GitHub fornece um modelo de fluxo de trabalho do Rust que deve funcionar na maioria dos projetos básicos de Rust. As seções subsequentes deste guia fornecem exemplos de como você pode personalizar esse modelo de fluxo de trabalho.

Em GitHub, acesse a página principal do repositório.
No nome do repositório, clique em Ações.
Se você já tiver um fluxo de trabalho no repositório, clique em Novo fluxo de trabalho.
A página "Escolher um fluxo de trabalho" mostra uma seleção de modelos de fluxo de trabalho recomendados. Pesquise por "Rust".
Filtre a seleção de fluxos de trabalho clicando em Integração contínua.
No fluxo de trabalho "Rust - by GitHub Actions", clique em Configurar.
Edite o fluxo de trabalho conforme necessário. Por exemplo, altere a versão do Rust.
Clique em Confirmar alterações.

O arquivo de fluxo de trabalho rust.yml é adicionado ao diretório .github/workflows do seu repositório.

Como especificar uma versão do Rust

Operadores hospedados no GitHub incluem uma versão recente da cadeia de ferramentas do Rust. Você pode usar o rustup para relatar a versão instalada em um operador, substituir a versão e instalar diferentes carrinhos de ferramentas. Para obter mais informações, confira The rustup book.

Este exemplo mostra as etapas que você pode usar para configurar o ambiente do executor para usar o build noturno do rust e relatar a versão.

YAML

      - name: Temporarily modify the rust toolchain version
        run: rustup override set nightly
      - name: Output rust version for educational purposes
        run: rustup --version

      - name: Temporarily modify the rust toolchain version
        run: rustup override set nightly
      - name: Output rust version for educational purposes
        run: rustup --version

Memorizar dependências

Você pode armazenar em cache e restaurar as dependências usando a ação Armazenar em cache. Este exemplo pressupõe que o repositório contém um arquivo Cargo.lock.

YAML

      - name: Cache
      - uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
            target
          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}

      - name: Cache
      - uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
            target
          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}

Se você tiver requisitos personalizados ou precisar de controles mais refinados para o cache, explore outras opções de configuração para a ação cache. Para saber mais, confira Memorizar dependências para acelerar os fluxos de trabalho.

Criar e testar seu código

Você pode usar os mesmos comandos usados localmente para criar e testar seu código. Este fluxo de trabalho de exemplo demonstra como usar cargo build e cargo test em um trabalho:

YAML

jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        BUILD_TARGET: [release] # refers to a cargo profile
    outputs:
      release_built: ${{ steps.set-output.outputs.release_built }}
    steps:
      - uses: actions/checkout@v4
      - name: Build binaries in "${{ matrix.BUILD_TARGET }}" mode
        run: cargo build --profile ${{ matrix.BUILD_TARGET }}
      - name: Run tests in "${{ matrix.BUILD_TARGET }}" mode
        run: cargo test --profile ${{ matrix.BUILD_TARGET }}

jobs:
  build:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        BUILD_TARGET: [release] # refers to a cargo profile
    outputs:
      release_built: ${{ steps.set-output.outputs.release_built }}
    steps:
      - uses: actions/checkout@v4
      - name: Build binaries in "${{ matrix.BUILD_TARGET }}" mode
        run: cargo build --profile ${{ matrix.BUILD_TARGET }}
      - name: Run tests in "${{ matrix.BUILD_TARGET }}" mode
        run: cargo test --profile ${{ matrix.BUILD_TARGET }}

A palavra-chave release usada neste exemplo corresponde a um perfil de carga. Você pode usar qualquer perfil definido no arquivo Cargo.toml.

Como publicar seu pacote ou biblioteca em crates.io

Depois de configurar o fluxo de trabalho para criar e testar seu código, use um segredo para fazer logon em crates.io e publicar seu pacote.

YAML

      - name: Login into crates.io
        run: cargo login ${{ secrets.CRATES_IO }}
      - name: Build binaries in "release" mode
        run: cargo build -r
      - name: "Package for crates.io"
        run: cargo package # publishes a package as a tarball
      - name: "Publish to crates.io"
        run: cargo publish # publishes your crate as a library that can be added as a dependency

      - name: Login into crates.io
        run: cargo login ${{ secrets.CRATES_IO }}
      - name: Build binaries in "release" mode
        run: cargo build -r
      - name: "Package for crates.io"
        run: cargo package # publishes a package as a tarball
      - name: "Publish to crates.io"
        run: cargo publish # publishes your crate as a library that can be added as a dependency

Se houver erros ao compilar e empacotar o crate, verifique os metadados no manifesto, arquivo Cargo.toml, confira O formato de manifesto. Verifique também o arquivo Cargo.lock; confira Cargo.toml vs Cargo.lock.

Empacotar dados do fluxo de trabalho como artefatos

Após a conclusão de um fluxo de trabalho, você pode carregar os artefatos resultantes para análise ou para usar em outro fluxo de trabalho. Você pode adicionar essas etapas de exemplo ao fluxo de trabalho para carregar um aplicativo para uso por outro fluxo de trabalho.

YAML

      - name: Upload release artifact
        uses: actions/upload-artifact@v4
        with:
          name: <my-app>
          path: target/${{ matrix.BUILD_TARGET }}/<my-app>

      - name: Upload release artifact
        uses: actions/upload-artifact@v4
        with:
          name: <my-app>
          path: target/${{ matrix.BUILD_TARGET }}/<my-app>

Para usar o artefato carregado em um trabalho diferente, verifique se os fluxos de trabalho têm as permissões certas para o repositório. Confira Autenticação automática de token. Você pode usar essas etapas de exemplo para baixar o aplicativo criado no fluxo de trabalho anterior e publicá-lo em GitHub.

YAML

      - uses: actions/checkout@v4
      - name: Download release artifact
        uses: actions/download-artifact@v4
        with:
          name: <my-app>
          path: ./<my-app>
      - name: Publish built binary to GitHub releases
      - run: |
          gh release create --generate-notes ./<my-app>/<my-project>#<my-app>

      - uses: actions/checkout@v4
      - name: Download release artifact
        uses: actions/download-artifact@v4
        with:
          name: <my-app>
          path: ./<my-app>
      - name: Publish built binary to GitHub releases
      - run: |
          gh release create --generate-notes ./<my-app>/<my-project>#<my-app>

Como criar e testar o Rust

Neste artigo