Artefakterstellung mit GitHub Actions

Einführung

Im vorherigen Lab haben Sie die „Qualitätskontrolle“ (CI) kennengelernt. Nun folgt der nächste Schritt: die Paketierung.

Stellen Sie sich Software wie ein Produkt in einer Fabrik vor. Nachdem sie alle Qualitätstests bestanden hat, muss sie in eine Schachtel gelegt, versiegelt und beschriftet werden, bevor sie an Kunden versendet werden kann. In der Softwarewelt ist diese „Schachtel“ häufig ein Docker-Container.

Die paketierte Ausgabe nennen wir ein Artefakt. Nach der Erstellung müssen Artefakte in einer Registry gespeichert werden, damit spätere Phasen, etwa die Bereitstellung, exakt denselben Build abrufen können.

Diese Reproduzierbarkeit ist der entscheidende Gedanke. Die Bereitstellung sollte ein bekanntes Build-Produkt verwenden und den Code nicht auf jedem Zielsystem anders neu erstellen.

GitHub stellt dafür eine Registry namens GitHub Container Registry (GHCR) bereit.

In diesem Lab bringen Sie Ihren Roboterassistenten dazu,

Ihre Anwendung in einen Docker-Container zu verpacken,
sie mit einem Versions-Tag zu beschriften,
sie automatisch in das GitHub-Lager zu versenden (zu übertragen).

Voraussetzungen

Wir verwenden weiterhin das Repository github-actions-basics.

Dockerfile erstellen

Bevor der Roboter Ihre Anwendung verpacken kann, benötigt er Anweisungen. In Docker werden diese Anweisungen in einer speziellen Datei namens Dockerfile gespeichert.

Wechseln Sie in das Projektverzeichnis.

cd ~/project
git clone https://github.com/your-username/github-actions-basics.git
cd github-actions-basics

Hinweis: Ersetzen Sie your-username durch Ihren tatsächlichen GitHub-Benutzernamen.

Erstellen Sie eine Datei mit dem Namen Dockerfile (großes „D“, ohne Dateierweiterung) und folgendem Inhalt.

cat > Dockerfile << EOF
FROM node:16-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["node", "index.js"]
EOF

Diese Packliste weist den Roboter genau zu folgenden Aktionen an:

FROM node:16-alpine: Beginnen Sie mit einem schlanken Basissystem, auf dem Node.js bereits installiert ist.
WORKDIR /app: Erstellen Sie im Inneren der Schachtel ein Arbeitsverzeichnis.
COPY ...: Kopieren Sie die Projektdateien in die Schachtel.
RUN npm install: Installieren Sie die erforderlichen Abhängigkeiten in der Schachtel.
CMD ...: Wenn jemand diese Schachtel öffnet (startet), wird die Anwendung gestartet.

Fügen Sie diese Datei nun Ihrem Repository hinzu und übertragen Sie sie zu GitHub.

git add Dockerfile
git commit -m "Add Dockerfile"
git push

Publish-Workflow erstellen

Nun erstellen wir einen neuen Workflow für das Verpacken und Versenden. Wir nennen ihn docker-publish.yml.

Erstellen Sie die Datei:

touch .github/workflows/docker-publish.yml

Öffnen Sie die Datei mit nano.

nano .github/workflows/docker-publish.yml

Fügen Sie die folgende Konfiguration ein. Dabei führen wir ein neues Konzept namens permissions ein.

name: Docker Publish

on:
  push:
    branches: ["master", "main"]

permissions:
  contents: read
  packages: write

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

Warum benötigen wir Berechtigungen?

Standardmäßig hat der Roboter aus Sicherheitsgründen nur eingeschränkten Zugriff. Da der Roboter Dateien in Ihr GitHub-Konto, genauer gesagt in den Bereich „packages“, hochladen soll, müssen wir ihm ausdrücklich einen Schlüssel zum Lager geben. Genau das bewirkt packages: write.

Dies ist ein gutes Beispiel für das Prinzip der geringsten Berechtigung beim Entwurf von Pipelines. Workflows sollten nur die Berechtigungen erhalten, die sie für ihre jeweilige Aufgabe benötigen.

Speichern Sie die Datei und beenden Sie nano (Ctrl+X, Y, Enter).

Build- und Push-Schritte hinzufügen

Nun überprüfen wir den spannendsten Teil: den eigentlichen Build und Push.

Wir verwenden zwei offizielle Tools (Actions) von Docker:

docker/login-action: zum Anmelden im Lager.
docker/build-push-action: zum Erstellen der Schachtel und deren Versand.

Diese Phase verbindet CI und Bereitstellung. Nachdem die Tests erfolgreich waren, erstellt die Pipeline ein versioniertes Artefakt, das andere Systeme später bereitstellen können, ohne den Quellcode erneut zu erstellen.

Öffnen Sie .github/workflows/docker-publish.yml erneut.

nano .github/workflows/docker-publish.yml

Hängen Sie die folgenden Schritte an den Job build-and-push an:

- name: Log in to the Container registry
  uses: docker/login-action@v2
  with:
    registry: ghcr.io
    username: ${{ github.actor }}
    password: ${{ secrets.GITHUB_TOKEN }}

- name: Build and push Docker image
  uses: docker/build-push-action@v4
  with:
    context: .
    push: true
    tags: ghcr.io/${{ github.repository }}/app:latest

Die magischen Variablen verstehen:

ghcr.io: Dies ist die Adresse des GitHub-„Lagers“.
${{ github.actor }}: Diese Variable wird automatisch mit Ihrem GitHub-Benutzernamen gefüllt.
${{ secrets.GITHUB_TOKEN }}: Dies ist ein spezielles, temporäres Passwort, das GitHub für den Roboter erstellt. Sie müssen nichts weiter tun – es funktioniert automatisch. Mit diesem Token kann sich der Roboter sicher anmelden, ohne dass Sie Ihr Passwort eingeben müssen.
tags: Damit wird das Etikett für Ihre Schachtel erstellt. Das Format lautet: Lageradresse / Ihr Name / Repository-Name / App-Name : Version.

Speichern Sie die Datei und beenden Sie nano.

Übertragen Sie diesen Workflow nun zu GitHub, um den Prozess zu starten.

git add .
git commit -m "Add Docker publishing workflow"
git push

Artefakt überprüfen

Ihr Roboter arbeitet nun intensiv. Er richtet einen Server ein, meldet sich an, erstellt Ihren Container und lädt ihn hoch.

Öffnen Sie Ihr Repository auf GitHub.
Klicken Sie auf die Registerkarte Actions.
Klicken Sie auf den Lauf des Workflows „Docker Publish“.
Beobachten Sie, wie die einzelnen Schritte grün werden.

Docker Publish

Sobald der Schritt „Build and push Docker image“ erfolgreich abgeschlossen ist, befindet sich Ihr Paket im Lager. Sehen wir es uns an.

Öffnen Sie die Hauptseite Ihres Repositorys, also die Registerkarte Code.
Sehen Sie in der rechten Seitenleiste nach. Dort sollte ein Bereich mit dem Titel Packages angezeigt werden.
Dort wird ein neues Paket aufgeführt.

Klicken Sie auf den Paketnamen, um die Details anzuzeigen. Dies ist Ihr fertiges Artefakt. Jede Person mit Zugriff auf Ihr Repository – beziehungsweise die Öffentlichkeit, wenn Ihr Repository öffentlich ist – kann Ihre Anwendung nun mithilfe dieses Images herunterladen und ausführen.

GitHub Packages

Zusammenfassung

In diesem Lab haben Sie eine vollständige Bereitstellungspipeline erstellt.

Sie haben gelernt:

Paketierung: Wie Sie eine Dockerfile schreiben, um Ihre Anwendung in einen Container zu verpacken.
Berechtigungen: Wie Sie Ihrem Workflow Schreibzugriff auf Ihre Pakete gewähren.
Lagerung: Wie Sie die GitHub Container Registry (GHCR) verwenden, um Ihre Images zu speichern.
Automatisierung: Wie Sie Ihren Code mithilfe von Standard-Actions automatisch erstellen und versenden.

Ihr Roboterassistent kann Ihren Code nun überprüfen (CI) und Ihren Code als Artefakt versenden. Im nächsten Lab sehen wir uns an, wie Sie vertrauliche Informationen wie Passwörter sicher verwalten.