Compilación y prueba de Rust

Puedes crear un flujo de trabajo de integración continua (CI) para compilar y probar tu proyecto de Rust.

En este artículo

Note

Actualmente los ejecutores hospedados por GitHub no se admiten en GitHub Enterprise Server. Puede ver más información sobre la compatibilidad futura planeada en GitHub public roadmap.

Introducción

Esta guía te muestra cómo compilar, probar y publicar un paquete de Rust.

Los ejecutores hospedados en GitHub tienen un caché de herramientas con software preinstalado, que incluye las dependencias para Rust. Para obtener una lista completa de software actualizado y las versiones preinstaladas de Rust, consulta Acerca de los ejecutores hospedados en GitHub.

Requisitos previos

Ya debes estar familiarizado con la sintaxis de YAML y con cómo se utiliza con GitHub Actions. Para más información, consulta Sintaxis del flujo de trabajo para GitHub Actions.

Te recomendamos que tengas un entendimiento básico del lenguaje Rust. Para más información, consulta Introducción a Rust.

Uso de una plantilla de flujo de trabajo de Rust

Para comenzar rápidamente, agregue una plantilla de flujo de trabajo al directorio .github/workflows del repositorio.

GitHub proporciona una plantilla de flujo de trabajo de Rust que debería funcionar para la mayoría de los proyectos de Rust. En las secciones siguientes de esta guía se proporcionan ejemplos de cómo puede personalizar esta plantilla de flujo de trabajo.

  1. En GitHub, navegue hasta la página principal del repositorio.

  2. En el nombre del repositorio, haz clic en Acciones.

    Captura de pantalla de las pestañas del repositorio "github/docs". La pestaña "Proyectos" aparece resaltada con un contorno naranja.

  3. Si ya tiene un flujo de trabajo en su repositorio, haga clic en New workflow (Nuevo flujo de trabajo).

  4. En la página "Elegir un flujo de trabajo" se muestra una selección de plantillas de flujo de trabajo recomendadas. Busca "Rust".

  5. Filtra la selección de flujos de trabajo con un clic en Integración continua.

  6. En el flujo de trabajo "Rust - by GitHub Actions", haz clic en Configurar.

    Captura de pantalla de la página «Elegir un flujo de trabajo». El botón "Configurar" en el flujo de trabajo "Rust" está resaltado con un contorno naranja.
    Si no encuentras la plantilla de flujo de trabajo "Rust, mediante GitHub Actions", copia el siguiente código de flujo de trabajo en un nuevo archivo llamado rust.yml en el directorio .github/workflows del repositorio.

    YAML
    name: Rust

on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

env:
  CARGO_TERM_COLOR: never

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - name: Build
      run: cargo build --verbose
    - name: Run tests
      run: cargo test --verbose

  7. Edita el flujo de trabajo según sea necesario. Por ejemplo, cambia la versión de Rust.

  8. Haga clic en Commit changes (Confirmar cambios).

Especificación de una versión de Rust

Los ejecutores hospedados en GitHub incluyen una versión reciente de la cadena de herramientas de Rust. Puedes usar rustup para notificar la versión instalada en un ejecutor, invalidar la versión e instalar cadenas de herramientas diferentes. Para más información, consulta El libro de rustup.

En este ejemplo se muestran los pasos que puedes usar para configurar el entorno del ejecutor a fin de usar la compilación nocturna de Rust y notificar la versión.

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

Almacenar dependencias en caché

Puedes almacenar en caché las dependencias y restaurarlas mediante la acción Cache. En este ejemplo se supone que el repositorio contiene un archivo Cargo.lock.

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

Si tienes requisitos personalizados o necesitas controles más precisos para el almacenamiento en caché, debes explorar otras opciones de configuración para la acción cache. Para más información, consulta Almacenar en caché las dependencias para agilizar los flujos de trabajo.

Construir y probar tu código

Puedes usar los mismos comandos que usas de forma local para construir y probar tu código. En este flujo de trabajo de ejemplo se muestra cómo usar cargo build y cargo test en un trabajo:

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 }}

La palabra clave release usada en este ejemplo corresponde a un perfil de carga. Puedes usar cualquier perfil que hayas definido en el archivo Cargo.toml.

Publicación del paquete o la biblioteca en crates.io

Una vez que hayas configurado el flujo de trabajo para compilar y probar el código, puedes usar un secreto a fin de iniciar sesión en crates.io y publicar el paquete.

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

Si hay algún error al compilar y empaquetar el formato .CR8, comprueba los metadatos del manifiesto, el archivo Cargo.toml y consulta El formato de manifiesto. También debes comprobar el archivo Cargo.lock; consulta Diferencias entre Cargo.toml y Cargo.lock.

Empaquetar datos de flujo de trabajo como artefactos

Después de que se complete un flujo de trabajo, puedes cargar los artefactos que se den como resultado para su análisis o para usarlos en otro flujo de trabajo. Puedes agregar estos pasos de ejemplo al flujo de trabajo para cargar una aplicación a fin de que la use otro flujo de trabajo.

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

A fin de usar el artefacto cargado en un trabajo diferente, asegúrate de que los flujos de trabajo tienen los permisos adecuados para el repositorio; consulta Autenticación automática de tokens. Puedes usar estos pasos de ejemplo para descargar la aplicación creada en el flujo de trabajo anterior y publicarla en GitHub.

YAML
      - uses: actions/checkout@v4
      - name: Download release artifact
        uses: actions/download-artifact@v3
        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>