Zum Inhalt springen

Rails in GitHub Actions beschleunigen

Zuletzt aktualisiert am

Um Rails in GitHub Actions zu beschleunigen, cachen Sie Ihre Gems mit ruby/setup-ruby, verzichten Sie auf das Precompilieren von Assets, die Sie nicht testen, bereiten Sie die Datenbank aus einer Schema-Datei vor, statt jede Migration auszuführen, und verteilen Sie Ihre Testsuite auf parallele Prozesse und Jobs. Der größte Teil der Rails-CI-Zeit entfällt auf den Boot, das Datenbank-Setup und einen langen Testlauf in einem einzigen Prozess.

Dies ist die Rails-Version unseres allgemeinen Leitfadens für schnellere GitHub Actions. Dieselben Ansätze gelten für RSpec und Minitest.

Wo Rails-CI seine Zeit verbringt

Führen Sie einen Build aus und lesen Sie die Schrittzeiten. Bei einer typischen Rails-App ist die Reihenfolge: Gem-Installation (cachen Sie sie), Datenbank-Setup (oft 20 bis 60 Sekunden), JavaScript- und Asset-Build (falls Sie Systemtests haben) und der Testlauf selbst. Der Testlauf ist meist der größte Posten. Gehen Sie die Punkte nach Aufwand an, nicht nach Größe.

Gems einfach cachen

ruby/setup-ruby kann Gems für Sie installieren und cachen. Laut README bewirkt bundler-cache: true, dass bundle install ausgeführt und die Gems automatisch gecacht werden, wobei das Lockfile in den Cache-Schlüssel einfließt.

- uses: ruby/setup-ruby@v1
  with:
    bundler-cache: true

Die Ruby-Version wird aus .ruby-version oder .tool-versions gelesen, wenn Sie ruby-version nicht setzen. Falls ein gecachter Gem-Satz beschädigt ist, setzen Sie cache-version: 1 (ein anderer Wert als 0), um neu zu beginnen. Fügen Sie für vendor/bundle keinen zweiten Schritt actions/cache hinzu; die Action erledigt das bereits.

Datenbank aus dem Schema vorbereiten

Ein frisch gestarteter Postgres-Service ist leer. 400 Migrationen in jedem Job auszuführen ist langsam und fehleranfällig. Laden Sie stattdessen das Schema. Hier ist ein vollständiger Job mit Postgres- und Redis-Services:

jobs:
  test:
    runs-on: ubuntu-latest
    timeout-minutes: 25
    services:
      postgres:
        image: postgres:17
        env:
          POSTGRES_PASSWORD: postgres
        ports: ["5432:5432"]
        options: >-
          --health-cmd "pg_isready -U postgres"
          --health-interval 5s --health-timeout 5s --health-retries 10
      redis:
        image: redis:7
        ports: ["6379:6379"]
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 5s --health-timeout 5s --health-retries 10
    env:
      RAILS_ENV: test
      DATABASE_URL: postgres://postgres:postgres@localhost:5432/app_test
      REDIS_URL: redis://localhost:6379/0
    steps:
      - uses: actions/checkout@v7
      - uses: ruby/setup-ruby@v1
        with:
          bundler-cache: true
      - run: bin/rails db:schema:load
      - run: bundle exec rspec

Committen Sie db/schema.rb oder db/structure.sql und halten Sie es aktuell. Health-Checks sind wichtig: Ohne sie kann der erste Test laufen, bevor Postgres Verbindungen annimmt, und Sie erhalten zufällige Fehler, die wie instabile Tests aussehen.

Eine Wegwerf-Testdatenbank braucht keine Dauerhaftigkeit. Wenn Sie Postgres selbst starten, machen -c fsync=off -c synchronous_commit=off -c full_page_writes=off Schreibvorgänge günstiger. Verwenden Sie das niemals für echte Daten.

Bootsnap und Boot-Zeit

Bootsnap cacht Ruby-Ladepfade und kompilierten Bytecode und ist im Standard-Gemfile neuerer Rails-Apps enthalten. Der Cache liegt in tmp/cache/bootsnap, der auf einer frischen VM leer ist, daher ist der erste Boot langsam. Cachen Sie ihn:

- uses: actions/cache@v6
  with:
    path: tmp/cache/bootsnap
    key: bootsnap-${{ runner.os }}-${{ hashFiles('Gemfile.lock', '.ruby-version') }}

Der Gewinn beträgt ein paar Sekunden pro Job. Er ist am größten, wenn Sie in viele parallele Jobs aufteilen, da jeder die Boot-Kosten trägt.

Arbeit überspringen, die Ihre Tests nicht brauchen

  • Assets. Wenn nur Systemtests kompilierte Assets benötigen, führen Sie bin/rails assets:precompile nur in diesem Job aus. Cachen Sie node_modules über actions/setup-node.
  • Eager Loading. Die Einstellung config.eager_load = ENV["CI"].present? in der Test-Umgebung fängt Ladefehler ab, erhöht aber die Boot-Zeit pro Prozess. Erwägen Sie sie nur für einen Job.
  • Logging. Setzen Sie config.log_level = :warn in der Testumgebung; ausführliche Debug-Logs verlangsamen große Suiten.
  • Systemtests. Legen Sie Browsertests in einen eigenen Job, damit sie Unit- und Request-Specs nicht blockieren. Siehe instabile E2E-Tests, falls sie unzuverlässig sind.

Testsuite aufteilen

Ein einzelnes bundle exec rspec läuft in einem Prozess. Zwei Hebel stehen zur Verfügung:

  1. Prozesse auf einer Maschine. Das Gem parallel_tests verteilt Spec-Dateien auf CPU-Kerne, mit einer Datenbank pro Prozess (parallel_rspec spec). Rails bietet für Minitest außerdem das eingebaute parallelize(workers: :number_of_processors).
  2. Jobs auf mehreren Maschinen. Verwenden Sie eine Matrix und teilen Sie Dateien nach gemessener Laufzeit auf. Knapsack verteilt nach Zeiten; parallel_tests kann nach Laufzeit aus einer Logdatei gruppieren.

Eine Matrix mit parallel_tests-Gruppierung (hier ist -n 4 die Gesamtzahl der Gruppen):

strategy:
  fail-fast: false
  matrix:
    group: [1, 2, 3, 4]
steps:
  - uses: actions/checkout@v7
  - uses: ruby/setup-ruby@v1
    with:
      bundler-cache: true
  - run: bin/rails db:schema:load
  - run: bundle exec parallel_rspec --only-group ${{ matrix.group }} --group-by runtime -n 4 spec

Geben Sie parallel_tests ein Laufzeit-Log (tmp/parallel_runtime_rspec.log, das Sie als Artefakt oder Cache speichern können), damit die Gruppen ausgeglichen sind. Ohne Log wird auf die Dateigröße zurückgegriffen. Mehr zu dieser Idee finden Sie unter Test-Sharding in GitHub Actions, und der Shard-Rechner für Tests schätzt eine Shard-Anzahl.

Kerne und Rails

Rails-Tests bestehen meist aus Ruby-Code in einem Prozess, der einen Kern nutzt. Eine größere Maschine hilft daher erst, wenn Sie parallel_tests oder Minitest parallelize einsetzen, um die Kerne zu nutzen. Dann können 8 vCPUs 8 Worker in einem Job ausführen, statt vier Jobs zu bezahlen, die jeweils Boot und Installation wiederholen. Eine Rails-Zeile haben wir in unseren Benchmarks nicht, daher nennen wir keine Beschleunigung.

Sie können Ihre eigene Suite auf compiler.dev testen, indem Sie eine Zeile zu runs-on: [self-hosted, Linux, compiler-ci] ändern. Siehe Preise und den Runner-Größenwähler. Verwandt: die Rails-Vorlage, Caching in GitHub Actions und langsame CI.

FAQ

Wie cache ich Gems für Rails in GitHub Actions?

Verwenden Sie ruby/setup-ruby mit bundler-cache: true. Es installiert Gems und cacht sie anhand Ihrer Gemfile.lock.

Ist parallel_tests oder eine Job-Matrix besser für Rails?

Verwenden Sie parallel_tests, um die Kerne einer Maschine auszulasten, und eine Matrix, um auf mehrere Maschinen zu verteilen. Viele Teams kombinieren beides: eine Matrix mit 3 bis 4 Jobs, die jeweils mehrere Prozesse ausführen.

Warum sind meine Rails-Tests nur in CI instabil?

Häufige Ursachen: Postgres ist nicht bereit (fügen Sie einen Health-Check hinzu), gemeinsamer Zustand zwischen parallelen Prozessen (verwenden Sie eine Datenbank pro Prozess) und zeitabhängige Tests.

Sollte ich in der CI db:migrate oder db:schema:load ausführen?

Laden Sie für mehr Geschwindigkeit das Schema. Führen Sie Migrationen in einer separaten Prüfung aus, um sicherzustellen, dass sie weiterhin angewendet werden.

Diesen Workflow auf compiler.dev ausführen Keine Karte nötig · 200 kostenlose Minuten

Kostenlos testen