CI/CD with GitHub Actions & DevOps Pipelines · Lekcja

Buforowanie zależności na rzecz szybkości

Zaimplementują Państwo buforowanie, aby znacznie przyspieszyć wykonywanie workflow przez ponowne wykorzystanie wygenerowanych zależności i artefaktów kompilacji.

Buforowanie zależności na rzecz szybkości to bezpłatna lekcja CI/CD with GitHub Actions & DevOps Pipelines na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej CI/CD with GitHub Actions & DevOps Pipelines, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs CI/CD with GitHub Actions & DevOps Pipelines zawiera 4 lekcji w sumie.

Przyspieszanie przepływów pracy dzięki buforowaniu

Czy zdarza się Państwu zauważyć, że przepływ pracy za każdym razem ponownie pobiera te same zależności? To spowalnia działanie!

Buforowanie w GitHub Actions pozwala przechowywać i ponownie wykorzystywać pliki z poprzednich uruchomień. Znacznie przyspiesza to kolejne wykonania przepływu pracy.

Poznaj akcję cache

GitHub udostępnia specjalną akcję o nazwie actions/cache@v3. Służy ona do zapisywania i przywracania plików, dzięki czemu przepływy pracy działają szybciej.

Jest inteligentna: przed próbą przywrócenia sprawdza, czy pamięć podręczna już istnieje, a jeśli nie, zapisuje ją.

Klucz i ścieżka pamięci podręcznej

Dwa kluczowe parametry akcji actions/cache to key i path:

key: unikatowy ciąg znaków identyfikujący pamięć podręczną. Jeśli zostanie znaleziona pamięć podręczna z tym kluczem, zostanie przywrócona.
path: ścieżki plików lub katalogi, które mają być buforowane. Informuje to akcję, *co* należy zapisać lub przywrócić.

Klucz często zawiera skrót plików zależności, aby pamięć podręczna została unieważniona po zmianie zależności.

Buforowanie zależności Node.js

Zbuforujmy katalog node_modules dla projektu Node.js. Użyjemy hashFiles, aby utworzyć dynamiczny klucz na podstawie pliku package-lock.json.

Proszę uruchomić ten prosty fragment przepływu pracy:

name: Node.js CI with Cache

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Cache Node.js modules
      uses: actions/cache@v3
      with:
        path: node_modules
        key: npm-${{ hashFiles('package-lock.json') }}
        restore-keys: |
          npm-
    - name: Install dependencies
      run: npm ci
    - name: Run tests
      run: npm test

Rezerwowe klucze przywracania

Co się stanie, jeśli dokładny key nie będzie pasować do żadnej pamięci podręcznej? W takiej sytuacji przydatne są restore-keys!

restore-keys udostępnia listę rezerwowych kluczy, których należy szukać. Jeśli główny klucz, na przykład npm-${{ hashFiles(...) }}, nie znajdzie dopasowania, GitHub Actions próbuje znaleźć pamięć podręczną za pomocą kolejnych wartości restore-keys.

W naszym przykładzie npm- służy do znalezienia dowolnej pamięci podręcznej zaczynającej się od "npm-". Jest to przydatne, gdy zmieniły się tylko drobne wersje zależności.

Buforowanie zależności Pythona

Buforowanie nie dotyczy wyłącznie Node.js! Tę samą zasadę można zastosować do innych języków, takich jak Python. W tym przypadku buforujemy środowisko wirtualne Pythona i pamięć podręczną pip.

Klucz korzysta tutaj z funkcji hashFiles('requirements.txt'), a ścieżka wskazuje środowisko wirtualne i katalog pamięci podręcznej pip.

name: Python CI with Cache

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Set up Python
      uses: actions/setup-python@v5
      with:
        python-version: '3.x'
    - name: Cache Python dependencies
      uses: actions/cache@v3
      with:
        path: |
          ~/.cache/pip
          .venv
        key: pip-${{ hashFiles('requirements.txt') }}
        restore-keys: |
          pip-
    - name: Install dependencies
      run: |
        python -m venv .venv
        .venv/bin/pip install -r requirements.txt
    - name: Run tests
      run: .venv/bin/python -m unittest discover

Kiedy unieważniać pamięć podręczną

Pamięć podręczna jest przydatna tylko wtedy, gdy jest wystarczająco aktualna. Jeśli zmienią się zależności, pamięć podręczna również powinna się zmienić!

Pamięć podręczna zostaje automatycznie unieważniona, gdy zmieni się główny key, na przykład npm-${{ hashFiles('package-lock.json') }}. Po zaktualizowaniu pliku package-lock.json zmienia się skrót i tworzona jest nowa pamięć podręczna.

Można również wymusić ponowne utworzenie pamięci podręcznej, ręcznie zmieniając klucz, na przykład dodając przyrostek wersji, taki jak npm-v2-${{ hashFiles(...) }}.

Zakres i ograniczenia pamięci podręcznej

Warto wiedzieć, jak działa buforowanie:

Zakres: pamięci podręczne mają zakres określony przez repozytorium i gałąź. Pamięć podręczna z gałęzi main nie zostanie użyta w gałęzi funkcjonalnej, chyba że jawnie skonfiguruje się lookup-path.
Limit rozmiaru: każda pamięć podręczna może mieć maksymalnie 10 GB.
Okres przechowywania: pamięci podręczne są przechowywane przez 7 dni od ostatniego dostępu. Stare, nieużywane pamięci podręczne są automatycznie usuwane.

Dobre praktyki buforowania

Aby w pełni wykorzystać buforowanie:

Używaj hashFiles: zawsze powiąż klucz pamięci podręcznej z plikami manifestu zależności, takimi jak package-lock.json czy requirements.txt.
Precyzyjnie określaj path: buforuj tylko to, co jest niezbędne, na przykład node_modules czy ~/.cache/pip.
Używaj restore-keys: podawaj rezerwowe klucze, aby zwiększyć odsetek trafień w pamięć podręczną.
Unikaj buforowania nietrwałych danych: nie buforuj plików, które często się zmieniają albo są bardzo duże i unikatowe dla każdego uruchomienia, takich jak artefakty kompilacji przeznaczone do wdrożenia.

Wyzwanie: klucz pamięci podręcznej

Mają Państwo projekt Java korzystający z Maven. Jego zależności są zdefiniowane w pliku pom.xml, a Maven zazwyczaj przechowuje pobrane pliki JAR w katalogu ~/.m2/repository.

Która konfiguracja pamięci podręcznej najlepiej gwarantuje buforowanie zależności Maven i ich prawidłowe unieważnianie po zmianie pliku pom.xml?

Podsumowanie: pamięć podręczna przyspiesza!

Świetnie! Poznali Państwo sposób implementowania buforowania w GitHub Actions, które znacznie przyspiesza przepływy pracy CI/CD.

Akcja actions/cache jest do tego przeznaczona.
Za pomocą key i path określa się, co i jak buforować.
hashFiles tworzy dynamiczne klucze na potrzeby inteligentnego unieważniania pamięci podręcznej.
restore-keys udostępnia przydatne rozwiązania rezerwowe.

Inteligentne buforowanie zależności pozwala oszczędzać czas kompilacji i zasoby obliczeniowe, zwiększając wydajność potoków!

Często zadawane pytania

Czy lekcja „Buforowanie zależności na rzecz szybkości” jest bezpłatna?

Tak — pełny tekst „Buforowanie zależności na rzecz szybkości” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu CI/CD with GitHub Actions & DevOps Pipelines, przejdź na CoddyKit PRO. Kurs CI/CD with GitHub Actions & DevOps Pipelines zawiera 4 lekcji w sumie.

Co nauczysz się w „Buforowanie zależności na rzecz szybkości”?

Zaimplementują Państwo buforowanie, aby znacznie przyspieszyć wykonywanie workflow przez ponowne wykorzystanie wygenerowanych zależności i artefaktów kompilacji. Ćwiczysz CI/CD with GitHub Actions & DevOps Pipelines z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć CI/CD with GitHub Actions & DevOps Pipelines?

Nie wymagamy żadnego doświadczenia. CI/CD with GitHub Actions & DevOps Pipelines w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Buforowanie zależności na rzecz szybkości”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji CI/CD with GitHub Actions & DevOps Pipelines?

Tak. Każda lekcja CI/CD with GitHub Actions & DevOps Pipelines zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Kompilacje macierzowe dla wielu środowisk
Buforowanie zależności na rzecz szybkości
Wielokrotnego użytku workflows i Actions
Warunkowe wykonywanie i zależności zadań

← Powrót do CI/CD with GitHub Actions & DevOps Pipelines