Warning: Undefined array key "pl" in /home/host1693024/python-3.com/htdocs/www/875348534534.php on line 2036
Ciągła integracja i wdrażanie Pythona z działaniami GitHub

Ciągła integracja i wdrażanie Pythona z działaniami GitHub

Tworzenie oprogramowania jest osiągnięciem, które warto świętować. Ale oprogramowanie nigdy nie jest statyczne. Błędy należy naprawić, należy dodać funkcje, a bezpieczeństwo wymaga regularnych aktualizacji. W dzisiejszym krajobrazie, wraz z dominującymi metodologią, solidne systemy DevOps są kluczowe dla zarządzania ewoluującą bazą kodu. Właśnie tam świecą działania GitHub, umożliwiając programistom Python do automatyzacji przepływów pracy i zapewnienia, że ich projekty bezproblemowo dostosowują się do zmiany.

Akcje GitHub dla Pythona umożliwiają programistom efektywną automatyzację przepływów pracy. Umożliwia to zespołom utrzymanie jakości oprogramowania przy jednoczesnym dostosowywaniu się do ciągłych zmian.

Systemy ciągłej integracji i ciągłego wdrażania (CI/CD) pomagają tworzyć dobrze przetestowane oprogramowanie wysokiej jakości i usprawniać wdrażanie. GitHub Actions sprawia, że CI/CD jest dostępne dla wszystkich, umożliwiając automatyzację i dostosowywanie przepływów pracy bezpośrednio w repozytorium. Ta bezpłatna usługa umożliwia programistom wydajną realizację procesów tworzenia oprogramowania, poprawiając produktywność i niezawodność kodu.

W tym samouczku nauczysz się:

  • Użyj GitHub Actions i przepływy pracy
  • Zautomatyzuj Linting, testowanie i wdrażanie projektu Python
  • bezpieczne poświadczenia używane do automatyzacji
  • Zautomatyzuj aktualizacje bezpieczeństwa i zależności

W tym samouczku użyje istniejącej bazy kodowej, Real Python Reader, jako punkt wyjścia, dla którego utworzysz rurociąg CI/CD. Możesz rozwidlić prawdziwy kod czytnika Pythona na GitHub, aby śledzić. Pamiętaj, aby odznaczyć opcję skopiuj opcję gałąź master podczas rozwidlenia. Alternatywnie, jeśli wolisz, możesz zbudować własny prawdziwy czytnik Python za pomocą poprzedniego samouczka.

Aby jak najlepiej wykorzystać ten samouczek, powinieneś czuć się komfortowo z pip , budowaniem pakietów Pythona, git i znajomości składni YAML.

Zanim zagłębisz się w działania GitHub, pomocne może być cofnięcie się i dowiedzieć się o korzyściach CI/CD. Pomoże ci to zrozumieć rodzaje problemów, które mogą rozwiązać działania GitHub.

Odblokowanie korzyści z CI/CD

Ciągła integracja (CI) i Ciągłe wdrażanie (CD), powszechnie znane jako CI/CD, to podstawowe praktyki w tworzeniu nowoczesnego oprogramowania. Praktyki te automatyzują integrację zmian w kodzie, wykonywanie testów i wdrażanie aplikacji. Pomaga to zespołom i współautorom oprogramowania typu open source częściej wprowadzać zmiany w kodzie w niezawodny i uporządkowany sposób.

Ponadto, publikując pakiety Python open source, CI/CD zapewni, że wszystkie żądania Pull (PRS) i wkład w pakiet zaspokoją potrzeby projektu przy standaryzowaniu jakości kodu.

Częstsze wdrażania z mniejszymi zmianami kodu zmniejszają ryzyko niezamierzonych zmian złamania , które mogą wystąpić z większymi, bardziej złożonymi wydaniami. Na przykład, nawet jeśli programiści mogą sformatować wszystkie kody za pomocą tych samych narzędzi i reguł kłaczowych, polityka może automatycznie blokować PRS, jeśli testy kodu nie przejdą.

W następnej sekcji dowiesz się, w jaki sposób przepływy pracy GitHub mogą pomóc w zaimplementowaniu CI/CD na repozytorium hostowanym na GitHub.

Odkrywanie przepływów pracy GitHub

Przepływy pracy Github są potężną cechą działań Github. Pozwalają na zdefiniowanie niestandardowych przepływów pracy automatyzacji dla repozytoriów. Niezależnie od tego, czy chcesz zbudować, przetestować lub wdrożyć kod, przepływy pracy GITHUB zapewniają elastyczne i konfigurowalne rozwiązanie, którego każdy projekt na GitHub może użyć za darmo, niezależnie od tego, czy repozytorium jest publiczne czy prywatne.

Mimo że istnieje wielu dostawców CI/CD, działania GITHUB stały się domyślnie wśród projektów open source na GitHub ze względu na jego ekspansywny ekosystem, elastyczność i niskie lub brak kosztów.

Anatomia pliku przepływu pracy

Pliki przepływu pracy to deklaratywnie zapisane pliki YAML o predefiniowanej strukturze, której należy przestrzegać, aby przepływ pracy działał pomyślnie. Twoje pliki przepływu pracy YAML są przechowywane i definiowane w folderze .github/workflows/ w katalogu głównym Twojego projektu.

Twój folder przepływu pracy może zawierać wiele plików przepływu pracy, z których każdy będzie wykonywał określone zadanie. Możesz nadać tym plikom przepływu pracy dowolną nazwę. Jednak ze względu na prostotę i czytelność powszechną praktyką jest nadawanie im nazw od zadań, które wykonują, np. test.yml.

Każdy plik ma kilka elementów, które są wymagane, ale wiele, wiele więcej jest opcjonalnych. Dokumentacja GitHub Actions jest dokładna i dobrze napisana, więc koniecznie ją sprawdź po zakończeniu czytania tego samouczka.

Plik przepływu pracy składa się z trzech głównych części: wyzwalacze, zadania i kroki. Omówisz je w następnych sekcjach.

Wyzwalacze przepływu pracy

Wyzwalacz to zdarzenie, które powoduje uruchomienie przepływu pracy. Istnieje wiele rodzajów wyzwalaczy. Najczęściej spotykane to te, które występują na:

  • Wyciągnij żądanie
  • popchnął zatwierdzenie do domyślnej gałęzi
  • Tagged Commit
  • Manual spust
  • Żądanie kolejny przepływ pracy
  • Nowy numer jest otwierany

Możesz także chcieć jeszcze bardziej ograniczyć wyzwalacze, ograniczając je do określonej gałęzi lub zestawu plików. Oto prosty przykład wyzwalacza, który uruchamia przepływ pracy po dowolnym wypchnięciu do głównej gałęzi:

on:
  push:
    branches:
      - main

Aby uzyskać szczegółowe informacje na temat wyzwalaczy, które nie zostały omówione w tym samouczku, możesz sprawdzić oficjalną dokumentację.

Teraz, gdy wiesz, w jaki sposób zdarzenia uruchamiają przepływy pracy, czas przyjrzeć się kolejnemu składnikowi pliku przepływu pracy: zadaniom.

Praca w przepływie pracy

Każdy przepływ pracy ma pojedynczą sekcję zadań , która jest pojemnikiem dla mięsa i ziemniaków przepływu pracy. Przepływ pracy może zawierać jedną lub więcej zadań, które będzie działać, a każde zadanie może zawierać jeden lub więcej kroków.

Oto przykład tego, jak wyglądałaby ta sekcja bez żadnych kroków:

# ...

jobs:
  my_first_job:
    name: My first job
  my_second_job:
    name: My second job

Kiedy tworzysz zadanie, pierwszą rzeczą do zrobienia jest zdefiniowanie biegacza, którego chcesz użyć do wykonania zadania. runner to maszyna wirtualna (VM) hostowana na GitHubie, która wykonuje Twoje zadania za Ciebie. GitHub zapewni i wyrejestruje maszynę wirtualną, dzięki czemu nie musisz się martwić o utrzymanie infrastruktury dla swojego CI/CD.

Dostępnych jest wiele obsługiwanych systemów operacyjnych. Pełną listę modułów uruchamiających hostowanych na GitHubie znajdziesz w dokumentacji.

Definiowanie biegacza wymaga zaledwie pojedynczej linii YAML:

# ...

jobs:
  my_first_job:
    name: My first job
    runs-on: ubuntu-latest
    # ...
  my_second_job:
    name: My second job
    runs-on: windows-latest
    # ...

W powyższym przykładzie my_first_job uruchomi się wewnątrz maszyny wirtualnej Ubuntu, a my_second_job uruchomi się wewnątrz VM Windows. Oba używają w tym przypadku sufiks -latest , ale możesz również określić dokładną wersję systemu operacyjnego-na przykład ubuntu-20.24 , o ile jest to obsługiwane wersja.

Kroki przepływu pracy

Kroki są główną częścią pracy. Jak zapewne domyślałeś się, kroki deklarują działania, które należy wykonać podczas wykonywania przepływu pracy. Może to obejmować zadania takie jak instalowanie Pythona, uruchamianie testów, kłaczanie kodu lub korzystanie z innej akcji GitHub.

Podobnie jak twój kod Python, wspólne i powtarzalne zadania można wyodrębnić w osobne przepływy pracy i ponownie wykorzystane. Oznacza to, że możesz i powinieneś korzystać z działań GitHub innych osób we własnych przepływach pracy, podobnie jak podczas importowania biblioteki Python, aby zaoszczędzić czas na ponowne wdrożenie tej funkcji.

W następnej sekcji zobaczysz, w jaki sposób możesz użyć innych działań GitHub i jak je znaleźć.

Korzystanie z akcji GitHub dla języka Python

Mimo że przepływy pracy są częścią działań GitHub, przepływy pracy mogą również zawierać działania GitHub. Innymi słowy, możesz użyć działań innych osób lub organizacji w swoim przepływie pracy. W rzeczywistości jest to powszechna praktyka i bardzo zachęcana do korzystania z istniejących działań GitHub w plikach przepływu pracy. Ta praktyka oszczędza czas i wysiłek, wykorzystując wstępnie zbudowane funkcje.

Jeśli masz określone zadanie do wykonania, prawdopodobnie dostępna jest akcja GitHub, która może to zrobić. Odpowiednie akcje GitHub znajdziesz w GitHub Marketplace, z którym zapoznasz się w dalszej części.

Odkrywanie rynku GitHub

GitHub Marketplace to internetowe repozytorium wszystkich działań, z których ludzie mogą korzystać w swoich własnych przepływach pracy. GitHub, zewnętrzni dostawcy i osoby fizyczne tworzą i utrzymują te akcje GitHub. Każdy może użyć szablonu akcji GitHub, aby utworzyć własną akcję i udostępnić ją na rynku.

Doprowadziło to do powstania szerokiej gamy akcji GitHub dostępnych dla niemal każdego rodzaju automatyzacji zadań, jaki można sobie wyobrazić. Wszystkie działania w GitHub Marketplace są open source i można z nich korzystać bezpłatnie.

W następnej sekcji przyjrzysz się dwóm akcjom GitHub, których będziesz używać w każdym projekcie w języku Python.

Uwzględnianie akcji w przepływach pracy

Każdy tworzony przepływ pracy oparty na Pythonie musi nie tylko sprawdzić swoje bieżące repozytorium w środowisku przepływu pracy, ale także zainstalować i skonfigurować Python. Na szczęście Github ma oficjalne działania Github, które pomogą w obu zadaniach:

# ...

jobs:
  my_first_job:
    name: My first job
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.13"
      - run: python -m pip install -r requirements.txt

W powyższym przykładzie widać, że pierwszym krokiem kroków jest użycie oficjalnej akcji checkout. Ta akcja powoduje wypisanie kodu z repozytorium do bieżącego obszaru roboczego GitHub, umożliwiając dostęp do niego w przepływie pracy. @4 następujący po checkout to specyfikator wersji, wskazujący, która wersja akcji ma zostać użyta. Obecnie najnowsza wersja to v4.2.2, więc możesz się do niej odwołać, używając tej składni, aby określić najnowszą wersję główną.

Drugi etap tego przykładu ustawia Pythona w środowisku. Ponownie, w tym przykładzie wykorzystuje do tego oficjalne działanie GitHub ze względu na jego ciągłe wsparcie i rozwój. Większość działań, jeśli nie wszystkie, ma dodatkowe konfiguracje, które możesz dodać do kroku.

Dokumentacja akcji konfiguracji Python zawiera pełną listę konfiguracji. Na razie minimum, którego potrzebujesz, aby zainstalować Python w środowisku przepływu pracy, polega na ogłoszeniu, która wersja Pythona chcesz zainstalować.

W ostatnim kroku przykładu używasz polecenia run. To polecenie umożliwia wykonanie dowolnego polecenia bash lub powershell, w zależności od tego, którego modułu uruchamiającego używasz w tym kroku. W tym przypadku instalujesz zależności projektu z pliku wymagań.

Mamy nadzieję, że widzisz, jak potężne mogą być akcje GitHub. Przy niewielkiej ilości kodu i wysiłku możesz w powtarzalny sposób skonfigurować środowisko gotowe do budowania, testowania i wdrażania projektu w języku Python.

Masz teraz podstawowe zrozumienie struktury pliku przepływu pracy i sposobu, w jaki możesz stworzyć swój pierwszy przepływ pracy dla projektu. W następnej sekcji zrobisz to z przykładem w świecie rzeczywistym.

Tworzenie pierwszego przepływu pracy

Czas przejść przez etapy dodawania CI/CD do istniejącego projektu rzeczywistego, prawdziwego czytelnika Pythona. Zanim dodasz przepływy pracy w celu testowania i wdrożenia tego pakietu, najpierw zacznij od kłaczkowania.

Liner to narzędzie, które analizuje Twój kod i szuka błędów, problemów stylistycznych i podejrzanych konstrukcji. Kładka pozwala na rozwiązywanie problemów i poprawę jakości kodu przed udostępnieniem jej innym. Rozpoczynając CI/CD z nadprzyjającą, upewnisz się, że kod jest czysty i czytelny przed wdrożeniem pakietu do PYPI.

Do tego przepływu pracy użyjesz Ruff do kodu Pythona. Ale jeśli jeszcze tego nie zrobiłeś, najpierw rozwijaj repozytorium, w tym wszystkie gałęzie, a następnie klon go. Pamiętaj, aby wymienić swoją nazwę użytkownika swoją nazwą użytkownika GitHub:

$ git clone git@github.com:your-username/reader.git
$ cd reader/
$ git checkout github-actions-tutorial
$ mkdir -p .github/workflows/

Po sklonowaniu rozwidlonego repozytorium i zmianie bieżącego katalogu roboczego będziesz musiał przełączyć się do istniejącej gałęzi o nazwie github-actions-tutorial. Jeśli taka gałąź jest niedostępna, najprawdopodobniej zapomniałeś odznaczyć opcję Kopiuj tylko gałąź master podczas forkowania. W takim przypadku powinieneś usunąć swój fork, wrócić do oryginalnego repozytorium, wykonać fork ponownie i upewnić się, że tym razem uwzględniłeś wszystkie gałęzie.

Po pomyślnym przejściu do właściwej gałęzi utwórz folder do przechowywania przepływów pracy. Folder ten powinien nosić nazwę workflows/ i stanowić podkatalog folderu .github/.

Teraz możesz utworzyć swój pierwszy przepływ pracy, w którym zdefiniujesz wyzwalacze, skonfigurować środowisko i zainstalować Ruff. Na początek możesz zdefiniować swoje wyzwalacze w pliku LINT.YML :

name: Lint Python Code

on:
  pull_request:
    branches:
      - master
  push:
    branches:
      - master
  workflow_dispatch:

Chociaż nie jest to wymagane, za najlepszą praktykę uważa się nadanie każdemu przepływowi pracy jasnej, czytelnej dla człowieka nazwy. Ta nazwa pojawi się w lewej kolumnie karty Działania w Twoim repozytorium GitHub. Pomaga zidentyfikować dostępne przepływy pracy i filtrować poprzednie przebiegi przepływu pracy:

Po zdefiniowaniu nazwy możesz skupić się na wyzwalaczach tego przepływu pracy. W powyższym kodzie zdefiniowano trzy różne wyzwalacze, które mogą inicjować przepływ pracy:

  1. Otwarcie żądania ciągnięcia
  2. Wypychanie lokalnych zatwierdzeń
  3. Wysyłanie przepływu pracy ręcznie

Pierwsze dwa uruchomią przepływ pracy w dowolnym zdarzeniu żądania push lub ściągania w gałęzi master . Oznacza to, że każda zmiana kodu spowoduje uruchomienie tego przepływu pracy, niezależnie od tego, czy naciskasz prosto do master , czy używasz żądania Pull, aby scalić kod w gałęzi master magazyn.

Nie jest oczywiste, co robi ostatni wyzwalacz. Zgodnie z dokumentacją jest powszechnie używany do ponownego uruchomienia przepływu pracy, który zakończył się niepowodzeniem z przyczyn niezwiązanych ze zmianami w kodzie, takimi jak wygasły klucz API. Jednakże wyzwalacz workflow_dispatch działa tylko wtedy, gdy plik przepływu pracy znajduje się w gałęzi domyślnej.

Po zdefiniowaniu wyzwalaczy nadszedł czas, aby przejść do następnego kroku tworzenia pliku przepływu pracy, który ma na celu zdefiniowanie zadań i skonfigurowanie środowiska:

name: Lint Python Code

on:
  pull_request:
    branches:
      - master
  push:
    branches:
      - master
  workflow_dispatch:

jobs:
  lint: # The name of the job
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.13"
          cache: "pip"

Większość tego kodu powinna wyglądać znajomo z wcześniejszych przykładów, ale istnieje kilka niewielkich różnic. Po pierwsze, wymieniłeś Job Lint , aby opisać, co robi. To tylko nazwa, dzięki czemu możesz wybrać dowolną nazwę, którą lubisz, o ile przestrzega składni YAML. Zdefiniowałeś również biegacza, którego będziesz używać do tego przepływu pracy jako Ubuntu-Latest .

Następnie zauważysz, że akcja setup-python jest teraz skonfigurowana tak, aby buforować zależności pip wszystkich zainstalowanych pakietów. Pomaga to przyspieszyć przepływ pracy w przyszłych uruchomieniach, jeśli wersje pakietu są takie same. Zamiast wyciągać je z PyPI, użyje wersji buforowanych.

Teraz, gdy Twój przepływ pracy ma zdefiniowany wyzwalacz i moduł uruchamiający, a także masz zainstalowane narzędzie do sprawdzania kodu i zainstalowany język Python, czas zainstalować Ruff i uruchomić go, aby wyczyścić kod. Możesz to zrobić, dodając jeszcze dwa kroki do zadania lint:

name: Lint Python Code

on:
  pull_request:
    branches:
      - master
  push:
    branches:
      - master
  workflow_dispatch:

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.13"
          cache: "pip"
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          python -m pip install ruff

      - name: Run Ruff
        run: ruff check --output-format=github

W dwóch ostatnich krokach zadania lint używasz polecenia run, które widziałeś wcześniej. Jako część składni YAML, w drugiej linii zauważysz symbol potoku (|). Oznacza to ciąg wielowierszowy. Polecenie run zinterpretuje poniższe wiersze jako osobne polecenia i wykona je po kolei.

Po zainstalowaniu Ruffa przepływ pracy w końcu kończy się, uruchamiając Ruff, aby szukać błędów nadpokojowych. Dzięki temu poleceniu możesz określić, że chcesz, aby wyjście zostało zoptymalizowane pod kątem uruchamiania w Github przepływ pracy za pomocą znacznika -FORMAT .

Gratulacje! Ukończyłeś swój pierwszy przepływ pracy. Po zatwierdzeniu tego przepływu pracy w repozytorium i wypchnięciu GitHub automatycznie uruchomi ten przepływ pracy linting, gdy spełniony zostanie warunek wyzwalacza. Możesz także uruchomić ten przepływ pracy ręcznie w dowolnym momencie w witrynie GitHub. Aby to zrobić, przejdź do karty Akcje w swoim repozytorium, wybierz żądany przepływ pracy po lewej stronie, a następnie kliknij Uruchom przepływ pracy:

Teraz, gdy masz już za sobą przepływ pracy i rozumiesz, jak działają przepływy pracy, czas stworzyć taki, który uruchomi zestaw testów w Real Python Reader.

Tworzenie automatycznego przepływu pracy testowania

Teraz, gdy masz już za sobą pierwszy przepływ pracy w GitHubie, czas przyjrzeć się temu, co prawdopodobnie będzie najważniejsze ze wszystkich przepływów pracy w tym pakiecie: testowaniu automatycznym.

Czytnik Real Python używa pytest jako platformy testowej. Biorąc pod uwagę to, czego już się nauczyłeś o GitHub Actions, możesz nawet zobaczyć, jak możesz edytować przepływ pracy lintingu, aby przekształcić go w przepływ pracy testowy. W końcu będziesz musiał wykonać te same kroki, aby przygotować się do uruchomienia pytest. Należy pamiętać, że testując pakiet oprogramowania, należy przetestować go na wszystkich obsługiwanych wersjach Pythona.

Najpierw jednak, podobnie jak w przypadku wszystkich przepływów pracy w GitHubie, musisz zadeklarować wyzwalacze przepływu pracy testowania:

name: Run Tests

on:
  push:
    branches:
      - master
  pull_request:
    branches:
      - master
  workflow_call:
  workflow_dispatch:

Wiele z powyższych jest takich samych jak poprzedni przepływ pracy z lintingiem, ale z jedną różnicą — teraz dostępny jest nowy wyzwalacz, workflow_call. Podobnie jak workflow_dispatch, workflow_call jest predefiniowanym wyzwalaczem, który umożliwia innym przepływom pracy wyzwalanie tego przepływu pracy.

Oznacza to, że jeśli masz przepływ pracy w przyszłości, który wymaga również, aby testy przeszły, zamiast powtarzać kod, możesz poprosić nowy przepływ pracy o użycie tego przepływu pracy. Następnie przepływ pracy spowoduje ten przepływ pracy jako jeden z jego kroków i zapewni, że przejdzie do innych kroków pracy. Więc nigdy więcej powtórzeń i możesz utrzymać krótsze i do rzeczy.

Chociaż nie będziesz używać tej metody ponownego wykorzystania przepływu pracy w przepływie pracy test.yml, osiągniesz to w ten sam sposób, w jaki wywołujesz inne akcje GitHub w pliku przepływu pracy, używając używa słowa kluczowego:

# Github-username/repo/path/to/workflow@version
- uses: realpython/reader/.github/workflows/test.yml@master

Tutaj możesz zobaczyć, że możesz ponownie użyć przepływu pracy, przekazując ciąg przypominający ścieżkę do używa . Powinno zacząć od nazwy użytkownika i repozytorium GitHub, a następnie ścieżka do pliku przepływu pracy, której chcesz użyć. @master informuje nowy przepływ pracy, że chcesz użyć wersji przepływu pracy z testu master . A teraz możesz zobaczyć, jak potężne mogą być działania GitHub. Ponowne wykorzystanie przepływów pracy jest ogromną zaletą działań GitHub.

Teraz, gdy zdefiniowałeś wyzwalacze do przepływu pracy, nadszedł czas, aby odpowiedzieć na pytanie: Jak testujesz w wielu wersjach Pythona? W następnej sekcji zobaczysz, w jaki sposób możesz raz zdefiniować swoje kroki i poprosić ich o wiele razy, przy czym każdy bieg znajduje się w innej wersji Pythona.

Testowanie na wielu wersjach Pythona

W przepływie pracy w kłaczkowaniu użyłeś akcji Setup-Python w swoich krokach , aby skonfigurować Python 3.13 w instancji Ubuntu, która wyglądała tak:

# ...

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.13"
          cache: "pip"
      # ...
# ...

Niestety nie możesz po prostu dodać listy wersji Pythona do python-version i gotowe. Potrzebujesz macierzy strategii do testowania na wielu wersjach Pythona.

Cytując oficjalną dokumentację:

Strategia macierzowa umożliwia użycie zmiennych w jednej definicji zadania w celu automatycznego utworzenia wielu uruchomień zadań w oparciu o kombinacje zmiennych. Można na przykład użyć strategii macierzowej, aby przetestować kod w wielu wersjach języka lub w wielu systemach operacyjnych. (Źródło)

Krótko mówiąc, jakiekolwiek zmienne zdefiniujesz w matrix, wykonają te same kroki w zadaniu, ale z użyciem tych zmiennych. W tym przypadku chcesz działać na różnych wersjach Pythona, ale możesz także użyć tego do uruchomienia lub zbudowania kodu w różnych systemach operacyjnych.

Ogłoszenie strategii jest stosunkowo proste. Przed zdefiniowaniem swoich kroków, ale w ramach pracy możesz zdefiniować wymaganą strategię:

name: Run Tests

on:
  push:
    branches:
      - master
  pull_request:
    branches:
      - master
  workflow_call:
  workflow_dispatch:

jobs:
  testing:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]

Jak widzisz, deklarujesz zmienną python-version, która jest tablicą numerów wersji. Świetnie, to pierwsza część gotowa! Druga część polega na poinformowaniu akcji setup-python, że chcesz używać tych wersji, za pomocą specjalnej składni zmiennej:

name: Run Tests

on:
  push:
    branches:
      - master
  pull_request:
    branches:
      - master
  workflow_call:
  workflow_dispatch:

jobs:
  testing:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]

    steps:
      - uses: actions/checkout@v4
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
          cache: "pip"

Krok konfiguracji Pythona przepływu pracy ma teraz dwie zmiany. Pierwszy to dodana Nazwa do kroku. Jak dowiedziałeś się wcześniej, nie jest to wymagane, ale pomoże ci ustalić, która wersja Pythona nie powiodła się, odwołując się do wersji Python w nazwie kroku. Jest to pomocne, biorąc pod uwagę, że ten krok będzie działał na pięć różnych wersji Pythona.

Druga zmiana polega na tym, że zamiast twardego kodowania numeru wersji w za pomocą: Python-Version Część Setup-Python , możesz teraz zapoznać się z Python- Wersja zdefiniowana w matrycy.

Github ma kilka specjalnych kontekstów, do których można uzyskać dostęp w ramach przepływów pracy. Matrix jest jednym z nich. Określając matrycę w ramach strategii, Python-Version stał się teraz właściwością kontekstu macierzy. Oznacza to, że możesz uzyskać dostęp do dowolnej zmiennej zdefiniowanej jako część macierzy za pomocą składni DOT (. ), na przykład matrix.python-Version .

Chociaż nie jest to coś, co należy zrobić w przypadku programu Real Python Reader, możesz zrobić to samo w przypadku różnych wersji systemu operacyjnego. Na przykład:

strategy:
  matrix:
    os: [ubuntu-latest, windows-latest]

Następnie możesz użyć tej samej notacji kropkowej, aby uzyskać dostęp do zmiennej zdefiniowanej w matrycy z matrix.os .

Teraz, gdy wiesz, jak używać macierzy do deklaratywnego wykonywania kroków przy użyciu innej wersji Pythona, czas na pełne ukończenie procesu testowania.

Finalizowanie przepływu pracy testowania

Aby zakończyć przepływ pracy, potrzeba jeszcze tylko kilku kroków. Teraz, gdy Python jest zainstalowany, przepływ pracy będzie musiał zainstalować zależności programistyczne, a następnie uruchomić pytest.

Prawdziwy pakiet czytnika Pythona używa plik konfiguracyjnego pyProject.toml do deklarowania jego zależności. Ma również opcjonalne zależności od programistów, które obejmują Pytest . Możesz je zainstalować w ten sam sposób, w jaki wcześniej zainstalowałeś RUFF, używając polecenia Uruchom :

name: Run Tests

on:
  push:
    branches:
      - master
  pull_request:
    branches:
      - master
  workflow_call:
  workflow_dispatch:

jobs:
  testing:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]

    steps:
      - uses: actions/checkout@v4
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
          cache: "pip"

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          python -m pip install .[dev]

Ten krok wystarczy, aby zainstalować wymagane zależności. Jedynym pozostałym krokiem jest uruchomienie pytest:

name: Run Tests

on:
  push:
    branches:
      - master
  pull_request:
    branches:
      - master
  workflow_call:
  workflow_dispatch:

jobs:
  testing:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]

    steps:
      - uses: actions/checkout@v4
      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
          cache: "pip"

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          python -m pip install .[dev]

      - name: Run Pytest
        run: pytest

W tym momencie masz zarówno przepływ pracy lintingu, jak i testowania, które są wyzwalane za każdym razem, gdy na wzorcu wystąpi zdarzenie PR lub push. Następnie zwrócisz uwagę na część CD CI/CD i dowiesz się, jak automatycznie opublikować pakiet w PyPI.

Automatycznie publikowanie pakietu do PYPI

Trzeci przepływ pracy uzupełnia to, co większość ludzi postrzega jako minimalny rurociąg CI/CD. Ten trzeci przepływ pracy stanowi powtarzalny i spójny sposób budowania i publikowania pakietu. Prawdziwy pakiet czytnika Pythona wykorzystuje powszechnie używaną bibliotekę Python kompilację do generowania plików dystrybucji Pythona, które można następnie wdrożyć w PYPI.

Kiedy przepływy pracy stają się nieco bardziej skomplikowane i obejmują wiele etapów lub zadań, zaleca się zapisanie kroków i przebiegu. Pomoże Ci to wykonać wszystkie kroki we właściwej kolejności, dzięki czemu akcje GitHub, których używasz, będą od początku poprawnie skonfigurowane. Zaoszczędzi to później czas, pomagając uniknąć potencjalnych błędów w procesie kompilacji.

Oto kroki przepływu pracy dla pliku wdrażania.yml :

  1. Skonfiguruj środowisko, instalując Pythona i budując zależności
  2. Zbuduj pakiet , umieszczając pliki wyjściowe w folderu dist/
  3. Opublikuj pliki dystrybucji na PYPI
  4. Utwórz wersję GitHub, jeśli została pomyślnie opublikowana

W następnej sekcji zajmiesz się dwoma pierwszymi pozycjami na liście i napiszesz znaczną część przepływu pracy.

Konfigurowanie i budowanie pakietu

Podobnie jak w przypadku dwóch ostatnich przepływów pracy, pierwszym krokiem jest zdefiniowanie wyzwalaczy przepływu pracy. Widziałeś kilka typowych czynników wyzwalających, które obracają się wokół typowych przepływów pracy programisty, ale automatycznie uwalnianie każdego nowego PR lub pchania do głównej gałęzi nie jest idealne dla prawdziwego czytelnika Pythona.

Bardziej sensowne jest uderzenie wersji pakietu po kilku żądaniach ciągnięcia, poprawkach błędów lub po dodaniu nowych funkcji. Nowoczesnym sposobem wyzwalania takiej wersji po wersji Bump jest użycie najlepszego przyjaciela programisty, Git.

Git pozwala oznaczyć zatwierdzenie, aby oznaczyć znaczący moment w rozwoju oprogramowania. Jest to często narzędzie wybierane przy definiowaniu nowej wersji. Akcje GitHub mają wbudowaną obsługę używania tagów Git jako wyzwalaczy za pomocą słowa kluczowego tags:

name: Publish to PyPI
on:
  push:
    tags:
      - "*.*.*"

Jak widać tutaj, wyzwalacze obsługują również wzorce globalne. Zatem gwiazdka (*) może pasować do dowolnego znaku w sekwencji. Wzorzec opisany powyżej dopasuje dowolny znak, po którym następuje przecinek dziesiętny (.), kolejny znak, kolejny przecinek dziesiętny i na końcu kolejny znak.

Oznacza to, że 1.0.0 ma prawidłowe dopasowanie, podobnie jak 2.5.60. Dopasowuje to wersję semantyczną używaną przez Real Python Reader. Możesz także użyć v*.*.*, jeśli wolisz. Tak więc twoje tagi GIT powinny zacząć od V , który oznacza wersję . Na przykład v1.0.0 byłby prawidłowym tagiem.

Aby uruchomić ten przepływ pracy, oznaczasz zatwierdzenie za pomocą nazwy wersji:

$ git tag -a "1.0.0" -m "1.0.0"
$ git push --tags

Wypchnięcie nowego tagu do GitHub uruchomi ten przepływ pracy. Następnie skonfigurujesz środowisko i zainstalujesz zależności:

name: Publish to PyPI
on:
  push:
    tags:
      - "*.*.*"

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Set up Python
      uses: actions/setup-python@v5
      with:
        python-version: "3.13"

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        python -m pip install .[build]

    - name: Build package
      run: python -m build

Najpierw definiujesz zadanie publikuj i instalujesz Python 3.13 w VM Ubuntu. Następny krok instaluje zależności kompilacji prawdziwego czytnika Pythona. W ostatnim etapie używasz tego samego polecenia Uruchom , którego użyłeś wcześniej, ale tym razem, zamiast uruchomić Ruff lub Pytest , zbudujesz prawdziwy czytnik Pythona pakiet. Domyślnie kompilacja umieści pliki dystrybucji w folderze o nazwie dist .

Doskonały! Wdrożyłeś pierwsze dwie główne części planu przepływu pracy. Zanim będziesz mógł wdrożyć w PYPI, powinieneś wiedzieć, jak zapewnić bezpieczeństwo swojego tokena PYPI API.

Utrzymanie bezpieczeństwa tajemnic

Jak dowiedziałeś się wcześniej, przepływy pracy uzyskują dostęp do specjalnych kontekstów, takich jak Matrix . Kolejnym kontekstem, do którego mają dostęp do wszystkich przepływów pracy, jest kontekst sekretów . Przechowując poufne dane jako sekret repozytorium , możesz upewnić się, że nigdy nie wyciekasz przypadkowo klawisze API, hasła lub inne poświadczenia. Twój przepływ pracy może uzyskać dostęp do tych wrażliwych poświadczeń przy użyciu kontekstu tajemnic .

Możesz dodać wpisy tajne do swojego repozytorium w witrynie GitHub. Po dodaniu nie można ich przeglądać ani edytować. Można je jedynie zastąpić nową wartością. Dobrym pomysłem jest przejrzenie dokumentacji GitHuba, aby dowiedzieć się, jak dodać wpisy tajne w witrynie GitHub. Oficjalne dokumenty są stale aktualizowane w przypadku wszelkich zmian w interfejsie użytkownika, co czyni je najlepszym źródłem wiedzy o korzystaniu z tej funkcji GitHub.

Wdrażanie pakietu

Po zabezpieczeniu klucza API jako sekretu Github możesz uzyskać do niego dostęp w przepływie pracy:

name: Publish to PyPI
on:
  push:
    tags:
      - "*.*.*"

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Set up Python
      uses: actions/setup-python@v5
      with:
        python-version: "3.13"

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        python -m pip install .[build]

    - name: Build package
      run: python -m build

    - name: Test publish package
      uses: pypa/gh-action-pypi-publish@release/v1
      with:
        user: __token__
        password: ${{ secrets.PYPI_API_TOKEN }}
        repository-url: https://test.pypi.org/legacy/

    - name: Publish package
      uses: pypa/gh-action-pypi-publish@release/v1
      with:
        user: __token__
        password: ${{ secrets.PYPI_API_TOKEN }}

Na tym etapie możesz skorzystać z oficjalnej akcji GitHub od Python Packaging Authority (PyPA), która zarządza PyPI. Ta akcja GitHub wykonuje większość pracy i wymaga jedynie odniesienia do tokena API PyPI. Ponownie, domyślnie będzie szukać w folderze dist nowej wersji pakietu do przesłania.

Zamiast używać tradycyjnej nazwy użytkownika i hasła do uwierzytelnienia w PYPI, najlepiej używać ustalonego tokena interfejsu API do automatycznych wydań.

Ponieważ używasz tokena API i nie ma nazwy użytkownika, użyj __token__, ponieważ nazwa użytkownika informuje akcję GitHub, że używane jest uwierzytelnianie tokenem. Podobnie jak w przypadku poprzedniej strategii macierzowej, możesz użyć notacji kropkowej, aby uzyskać dostęp do tajnego kontekstu, jak w secrets.PYPI_API_TOKEN.

Nazwa sekretu przechowywana w GitHubie nie ma znaczenia, o ile ma dla Ciebie sens. Sekret GitHub nosi nazwę PYPI_API_TOKEN, więc odwołujesz się do niego w przepływie pracy, używając tej nazwy.

Być może zauważyłeś, że przepływ pracy obejmuje etap testowy przed opublikowaniem pakietu w PyPI. Ten krok jest prawie identyczny z krokiem publikowania, z jedną kluczową różnicą: musisz podać repository-url, aby zastąpić domyślny adres URL i przekazać pakiet do test.pypi.org.

Korzystanie z TestPyPI to doskonały sposób na upewnienie się, że pakiet jest zbudowany i posiada prawidłową wersję. Pozwala zidentyfikować i rozwiązać wszelkie potencjalne problemy, które mogą powodować problemy podczas publikowania w głównym repozytorium PyPI.

Jeśli podążasz za własnym forkiem repozytorium i zamierzasz wypchnąć swoją wersję do PyPI, będziesz musiał zaktualizować nazwę projektu do unikalnej nazwy. Jeśli nie zaktualizujesz nazwy projektu, podczas próby przesłania projektu pojawi się błąd HTTP 403. Dzieje się tak, ponieważ nie masz uprawnień do publikowania pakietu realpython-reader w PyPI. Aktualizacja nazwy projektu umożliwi opublikowanie własnej wersji.

Jako przykład możesz dodać swoją nazwę użytkownika jako przedrostek do nazwy projektu:

[build-system]
requires      = ["setuptools>=61.0.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "username-realpython-reader"
# ...

Pozostał jeszcze tylko jeden etap przepływu pracy do wykonania — utworzenie wydania GitHub w celu promowania, a następnie bezpośrednie udostępnienie wydania. Zanim będziesz mógł to zrobić, poznasz zmienne środowiskowe GitHub.

Dostęp do zmiennych środowiskowych GitHub

Aby opublikować wydanie repozytorium Github, wymagany jest token Github. Być może użyłeś ich wcześniej, jeśli kiedykolwiek korzystałeś z API GitHub. Biorąc ryzyko bezpieczeństwa korzystania z osobistych tokenów GitHub w przepływach pracy, GitHub domyślnie tworzy token tylko do odczytu w kontekście Secrets. Oznacza to, że zawsze masz do niego dostęp, jeśli go potrzebujesz.

Ponadto każdy moduł uruchamiający GitHub domyślnie zawiera przydatny interfejs CLI GitHub. Dzięki temu wykonywanie niektórych zadań, np. tworzenie wydania, staje się o wiele prostsze. Interfejs CLI GitHub ma wiele sposobów uwierzytelniania użytkownika, jednym z nich jest ustawienie zmiennej środowiskowej o nazwie GITHUB_TOKEN.

Być może zobaczysz, dokąd to zmierza. Dostarczonego tokena GitHub można użyć do uzyskania dostępu do interfejsu CLI i ostatecznie stworzenia płynnego sposobu tworzenia wydania GitHub. Oto jak to będzie wyglądać w przepływie pracy:

name: Publish to PyPI
on:
  push:
    tags:
      - "*.*.*"

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Set up Python
      uses: actions/setup-python@v5
      with:
        python-version: "3.13"

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        python -m pip install .[build]

    - name: Build package
      run: python -m build

    - name: Test publish package
      uses: pypa/gh-action-pypi-publish@release/v1
      with:
        user: __token__
        password: ${{ secrets.PYPI_API_TOKEN }}
        repository-url: https://test.pypi.org/legacy/

    - name: Publish package
      uses: pypa/gh-action-pypi-publish@release/v1
      with:
        user: __token__
        password: ${{ secrets.PYPI_API_TOKEN }}

    - name: Create GitHub Release
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      run: |
        gh release create ${{ github.ref_name }} ./dist/* --generate-notes

Zobaczysz, że w liniach 39. i 40. przepływ pracy przypisuje token GitHub z kontekstu sekretów do zmiennej środowiskowej o nazwie GITHUB_TOKEN. Wszystkie wartości kluczy ustawione w env zostaną ustawione jako zmienne środowiskowe dla bieżącego kroku. Oznacza to, że po uruchomieniu interfejsu CLI GitHub (gh) będzie on miał dostęp do tokena poprzez przypisaną zmienną środowiskową. Interfejs wiersza polecenia GitHub nie może bezpośrednio uzyskać dostępu do samego kontekstu kluczy tajnych.

GitHub pozwala również uzyskać dostęp do specjalnego kontekstu o nazwie Github . Przepływ pracy odwołuje się do atrybutu nazwy_nomatu w kontekście github . Jest to zdefiniowane w dokumentach GitHub w następujący sposób:

Krótka nazwa gałęzi lub tagu, która wywołała przebieg przepływu pracy. (Źródło)

Zatem github.ref_name zostanie zastąpiony atrybutem, który wyzwolił przepływ pracy, czyli w tym przypadku nazwą tagu Git.

Powyższe polecenie gh utworzy wersję o tej samej nazwie, co znacznik użyty do uruchomienia wydania, prześle wszystkie pliki z ./dist i automatycznie wygeneruje informacje o wersji. Te informacje o wydaniu obejmują wszelkie wymagania PR, które programiści połączyli od czasu stworzenia ostatniego wydania, podając autorom odpowiednie linki i nazwy użytkowników za ich wkład.

Możesz dodać brakujące szczegóły do informacji o wersji. Pamiętaj, że wersje można edytować po utworzeniu, jeśli chcesz dołączyć dodatkowe informacje, takie jak informacje o przestarzałości.

Gratulacje! Masz teraz zautomatyzowane nadawanie, testowanie i wdrażanie. Możesz oznaczyć swoje najnowsze zatwierdzenie, a ostateczny przepływ pracy wdrażania powinien działać pomyślnie:

Teraz, gdy Real Python Reader ma potok CI/CD, który gwarantuje, że wszelkie przyszłe zmiany w bazie kodu będą solidne i będą wykorzystywać czytelny i spójny kod, możesz dodać jeszcze jeden przepływ pracy do Real Python Reader. Można powiedzieć, że jest to wisienka na torcie naszego tortu CI/CD.

W następnej sekcji dowiesz się, jak skonfigurować zależność, aby zautomatyzować aktualizacje bezpieczeństwa i zależności.

Automatyzacja aktualizacji zabezpieczeń i zależności

Podobnie jak kod Pythona, twoje przepływy pracy Github muszą być utrzymywane i utrzymywane na bieżąco. Ponadto biblioteki, na których polega prawdziwy kod czytelnika Pythona, zawsze się zmieniają i aktualizują, więc trudno jest nadążyć i zarządzać zależnościami.

Szczególnie trudno jest być informowane o wszelkich aktualizacjach bezpieczeństwa opublikowanych przez twoje zależności, jeśli nie aktywnie przestrzegasz projektu w GitHub lub mediach społecznościowych. Na szczęście Github ma przydatne narzędzie do pomocy w obu problemach. Wprowadź zależność!

DefETABOT to narzędzie do automatyzacji, które nie tylko powiadomi Cię o podatności bezpieczeństwa w zależnościach, ale jeśli zostanie skonfigurowana, automatycznie utworzy PR do aktualizacji i rozwiązania problemu dla Ciebie. Wszystko, co musisz zrobić, to przejrzeć zautomatyzowany PR i połączyć. Dzięki zależności, utrzymywanie pakietu na bieżąco i wolne od znanych luk w zabezpieczeniach jest szybkie i łatwe, oszczędzając czas, którego możesz użyć, aby ulepszyć kod lub dodać nowe funkcje.

Możesz skonfigurować Zależnego Robota tak, aby spełniał potrzeby Twojego projektu. Tutaj pakiet Real Python Reader ma dość podstawowe wymagania. Te dwa cele to:

  1. Aby otrzymać powiadomienie, gdy dostępna będzie aktualizacja zależności.
  2. Aby pomóc w utrzymaniu aktualności innych przepływów pracy.

Wymagania te są zdefiniowane w pliku konfiguracyjnym o nazwie dependentabot.yml. W przeciwieństwie do innych przepływów pracy, plik dependentabot.yml znajduje się w samym folderze .github, nie w .github/workflows.

Ponieważ ten plik ma tylko dwanaście linii i znasz teraz lepiej składnię YAML, możesz rzucić okiem na ostateczną konfigurację Zależnego Robota:

---
version: 2
updates:
  - package-ecosystem: "pip"
    directory: "/"
    schedule:
      interval: "weekly"

  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "weekly"

Właściwość version jest obowiązkową częścią pliku. W tym miejscu zdefiniujesz wersję programu Depabot, której chcesz używać, a wersja 2 jest najnowsza. Kolejną obowiązkową sekcją są aktualizacje. Tutaj odbywa się większość konfiguracji. Każda aktualizacja definiuje ekosystem pakietów do sprawdzenia, wraz z podstawowymi informacjami dotyczącymi tego, w którym katalogu Depabot powinien przeszukiwać i jak często.

Przy pierwszej aktualizacji Depabot sprawdzi typowe pliki, w których zwykle deklarowane są zależności pip, takie jak requirements.txt, pyproject.toml i inne . Ponieważ Real Python Reader ma plik pyproject.toml w katalogu głównym, Depabot otrzymuje polecenie, aby tam zajrzeć, jak wskazuje ukośnik ("/").

To, jak często chcesz otrzymywać powiadomienia o aktualizacjach zależności, zależy od Ciebie. Każdy projekt będzie miał swoje własne wymagania. Jednak zadeklarowanie go w YAML oznacza, że jeśli uznasz, że rytm jest za duży lub za niewystarczający, można go szybko i łatwo wprowadzić. Na razie możesz używać co tydzień.

Druga pozycja na liście updates dotyczy github-actions. Zgadza się, Depabot sprawdzi także akcje GitHub używane w dowolnym przepływie pracy w repozytorium, takie jak setup-python, pod kątem nowszych wersji! Dzięki temu śledzenie najnowszych wersji GitHub Actions jest automatyczne i jest to o jedną rzecz mniej, o którą musisz się martwić.

Po wdrożeniu tej konfiguracji Depabot będzie skanował i sprawdzał Twoje repozytorium raz w tygodniu, aby sprawdzić, czy są jakieś aktualizacje, które możesz wprowadzić w zależnościach lub przepływach pracy. Automatycznie utworzy PR z poprawką. Te żądania PR od Depabot będą również uruchamiać inne przepływy pracy, aby upewnić się, że zmiany w Depabot przejdą kontrolę lintingu i testów. Podwójne zwycięstwo!

Następne kroki

Jest wiele innych zadań, które możesz zautomatyzować w miarę rozwoju repozytorium, takich jak segregacja problemów, etykietowanie, zarządzanie nieaktualnymi problemami, dodawanie recenzentów do PR i nie tylko.

Należy również pamiętać, że GitHub Actions to tylko jeden z dostawców CI/CD. Jeśli Twój projekt jest hostowany na GitHubie, GitHub Actions może Ci to ułatwić. Jeśli Twój kod znajduje się na innej platformie lub chcesz wypróbować alternatywy, oto krótka lista innych dostawców CI/CD:

  • GitLab
  • Rurociągi Azure
  • Okrąg CI
  • Travis CI

Jeśli korzystasz już z jednego z tych dostawców lub takiego, którego nie ma na liście, nie wahaj się wykrzyczeć tego w komentarzach i podzielić się swoimi doświadczeniami.

Wniosek

Teraz wiesz, jak wdrożyć solidny rurociąg CI/CD dla projektu Python przy użyciu działań GitHub. Podczas gdy celem tego samouczka było nauczenie się dodawania CI/CD do istniejącej bazy kodowej, mam nadzieję, że znasz teraz wystarczająco dużo, aby pracować z własnymi projektami i pakietami i tworzyć własne przepływy pracy od zera.

W tym samouczku nauczyłeś się:

  • Używaj Akcji GitHub i przepływów pracy
  • Zautomatyzuj Linting, testowanie i wdrażanie projektu Python
  • Bezpieczne dane uwierzytelniające używane do automatyzacji
  • Zautomatyzuj aktualizacje bezpieczeństwa i zależności

Zautomatyzując te procesy, znacznie poprawiłeś możliwość utrzymania i niezawodności swojego projektu. Masz teraz spójny sposób na zapewnienie jakości kodu, uruchamiania testów i wdrożenia nowych wersji przy minimalnej interwencji ręcznej.

Pamiętaj, że CI/CD to proces iteracyjny. W miarę rozwoju i ewolucji projektu może zaistnieć potrzeba dostosowania przepływów pracy lub dodania nowych. Elastyczność GitHub Actions pozwala łatwo dostosować się do zmieniających się wymagań.

Dzięki tym narzędziom i praktykom jesteś dobrze wyposażony do skutecznego zarządzania i skalowania projektów Python.