Veröffentlichen und Installieren eines Pakets mit GitHub Actions

Informationen zu GitHub Packages with GitHub Actions

GitHub Actions helfen Dir, Deine Workflows für die Softwareentwicklung am gleichen Ort zu automatisieren, an dem Du Code speicherst und an Pull Requests und Issues mitarbeitest. Du kannst einzelne Aufgaben schreiben, Aktionen genannt, und diese kombinieren um einen benutzerdefinierten Workflow zu erstellen. Mit GitHub Actions können Sie End-to-End-Funktionen für die fortlaufende Integration und die fortlaufende Bereitstellung direkt im Repository erstellen. Weitere Informationen findest du unter Schreiben von Workflows.

Du kannst die CI- und CD-Funktionen deines Repositorys erweitern, indem du Pakete als Teil deines Workflows veröffentlichst oder installierst.

Authentifizieren bei Paketregistrierungen mit differenzierten Berechtigungen

Einige GitHub Packages-Registrierungen unterstützen differenzierte Berechtigungen. Das bedeutet, dass du festlegen kannst, dass Pakete auf Benutzer*innen oder eine Organisation ausgerichtet werden oder mit einem Repository verknüpft sein dürfen. Eine Liste dieser Registrierungen, die differenzierte Berechtigungen unterstützen, findest du unter Informationen zu Berechtigungen für GitHub-Pakete.

Wenn dein GitHub Actions-Workflow ein personal access token zum Authentifizieren bei einer Registrierung verwendet, solltest du für Registrierungen, die differenzierte Berechtigungen unterstützen, deinen Workflow unbedingt so aktualisieren, dass das GITHUB_TOKEN verwendet wird. Eine Anleitung zum Aktualisieren deiner Workflows, die sich mit einem personal access token bei einer Registrierung authentifizieren, findest du unter Veröffentlichen und Installieren eines Pakets mit GitHub Actions.

Sie können ein GITHUB_TOKEN in einem GitHub Actions-Workflow verwenden, um ein Paket mithilfe der REST-API zu löschen oder wiederherzustellen, wenn das Token über die admin-Berechtigung für das Paket verfügt. Repositorys, die Pakete mithilfe eines Workflows veröffentlichen, und Repositorys, die du explizit mit Paketen verbunden hast, erhalten automatisch die admin-Berechtigung für Pakete im Repository.

Weitere Informationen zum GITHUB_TOKEN findest du unter Automatische Tokenauthentifizierung. Weitere Informationen zu den Best Practices bei der Verwendung einer Registrierung in Actions findest du unter Sicherheitshärtung für GitHub Actions.

Authentifizieren bei Paketregistrierungen mit repositorybezogenen Berechtigungen

Einige GitHub Packages-Registrierungen unterstützen nur repositorybezogene Berechtigungen und keine differenzierten Berechtigungen. Eine Liste dieser Registrierungen findest du unter Informationen zu Berechtigungen für GitHub-Pakete.

Wenn dein Workflow Zugriff auf eine GitHub Packages-Registrierung benötigt, die keine differenzierten Berechtigungen unterstützt, empfehlen wir die Verwendung des GitHub-Tokens (GITHUB_TOKEN), das GitHub Enterprise Cloud automatisch für dein Repository erstellt, wenn du GitHub Actions aktivierst. Die Berechtigungen für dieses Zugriffstoken müssen in der Workflowdatei festgelegt werden, um den Lesezugriff auf den contents-Bereich und Schreibzugriff auf den packages-Bereich zu gewähren. Für Forks erhält GITHUB_TOKEN den Lesezugriff für das übergeordnete Repository. Weitere Informationen findest du unter Automatische Tokenauthentifizierung.

Du kannst auf das GITHUB_TOKEN in deiner Workflowdatei mithilfe des ${{ secrets.GITHUB_TOKEN }}-Kontexts verweisen. Weitere Informationen findest du unter Automatische Tokenauthentifizierung.

Informationen zu Berechtigungen und zum Paketzugriff

Auf Benutzer oder Organisationen ausgerichtete Pakete

Registrierungen, die differenzierte Berechtigungen unterstützen, ermöglichen es Benutzern, Pakete als eigenständige Ressourcen auf Organisationsebene zu erstellen und zu verwalten. Pakete können einer Organisation oder einem persönlichen Kontos zugeordnet werden, und du kannst den Zugriff auf jedes deiner Pakete separat über die Repositoryberechtigungen anpassen.

Alle Workflows, die auf Registrierungen zugreifen, die differenzierte Berechtigungen unterstützen, sollten kein personal access token verwenden, sondern das GitHub-Token (GITHUB_TOKEN). Weitere Informationen zu bewährten Methoden für die Sicherheit findest du unter Sicherheitshärtung für GitHub Actions.

Auf Repositorys ausgerichtete Pakete

Wenn du GitHub Actions aktivierst, installiert GitHub eine GitHub App im Repository. Das GITHUB_TOKEN-Geheimnis ist ein Zugriffstoken der GitHub-App-Installation. Du kannst das Installationszugriffstoken verwenden, um dich im Namen der auf deinem Repository installierten GitHub-App zu authentifizieren. Die Berechtigungen des Tokens sind auf das Repository beschränkt, in dem sich der Workflow befindet. Weitere Informationen findest du unter Automatische Tokenauthentifizierung.

GitHub Packages ermöglicht es dir, Pakete über das GITHUB_TOKEN zu pushen und pullen, das für einen GitHub Actions-Workflow verfügbar ist.

Standardberechtigungen und Zugriffseinstellungen für Pakete, die über Workflows geändert wurden

Wenn du für Pakete in Registrierungen, die differenzierte Berechtigungen unterstützen, ein Paket über einen Workflow erstellst, installierst, änderst oder löschst, gibt es einige Standardberechtigungen und Zugriffseinstellungen, die verwendet werden, um sicherzustellen, dass Administrator*innen Zugriff auf den Workflow haben. Du kannst diese Zugriffseinstellungen auch anpassen. Eine Liste dieser Registrierungen, die differenzierte Berechtigungen unterstützen, findest du unter Informationen zu Berechtigungen für GitHub-Pakete.

Standardmäßig geschieht Folgendes, wenn ein Workflow mithilfe von GITHUB_TOKEN ein Paket erstellt:

• Das Paket erbt das Sichtbarkeits- und Berechtigungsmodell des Repositorys, in dem der Workflow ausgeführt wird.
• Repositoryadministratorinnen, für die der Workflow ausgeführt wird, werden die Administratorinnen des Pakets, sobald dieses erstellt wurde.

Dies sind weitere Beispiele für die Funktionsweise von Standardberechtigungen für Workflows, die Pakete verwalten.

Du kannst auch den Zugriff auf Pakete präziser anpassen oder das Verhalten von Standardberechtigungen anpassen. Weitere Informationen findest du unter Konfigurieren der Zugriffssteuerung und Sichtbarkeit von Paketen.

Veröffentlichen eines Pakets mithilfe einer Aktion

Du kannst GitHub Actions verwenden, um automatisch Pakete als Teil deines CI-Flows (Continuous Integration) zu veröffentlichen. Mit diesem Ansatz für Continuous Deployment (CD) kannst du die Erstellung neuer Paketversionen automatisieren, wenn der Code deinen Qualitätsstandards entspricht. Beispielsweise kannst du einen Workflow erstellen, der CI-Tests jedes Mal ausführt, wenn eine Entwicklerin Code an einen bestimmten Branch pusht. Wenn die Tests bestanden werden, kann der Workflow eine neue Paketversion in GitHub Packages veröffentlichen.

Die Konfigurationsschritte variieren je nach Paketclient. Allgemeine Informationen zum Konfigurieren eines Workflows für GitHub Actions findest du unter Schreiben von Workflows.

Im folgenden Beispiel wird veranschaulicht, wie du GitHub Actions verwenden kannst, um deine App zu erstellen und zu testen und anschließend automatisch ein Docker-Image zu erstellen und es in GitHub Packages zu veröffentlichen. Die relevanten Einstellungen werden im Code erläutert. Weitere Informationen zu den einzelnen Elementen in einem Workflow findest du unter Workflowsyntax für GitHub Actions.

Erstelle eine neuen Workflowdatei in deinem Repository (z. B. .github/workflows/deploy-image.yml), und füge die folgende YAML-Datei hinzu.

#
name: Create and publish a Docker image

# Configures this workflow to run every time a change is pushed to the branch called `release`.
on:
  push:
    branches: ['release']

# Defines two custom environment variables for the workflow. These are used for the Container registry domain, and a name for the Docker image that this workflow builds.
env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

# There is a single job in this workflow. It's configured to run on the latest available version of Ubuntu.
jobs:
  build-and-push-image:
    runs-on: ubuntu-latest
    # Sets the permissions granted to the `GITHUB_TOKEN` for the actions in this job.
    permissions:
      contents: read
      packages: write
      attestations: write
      id-token: write
      # 
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      # Uses the `docker/login-action` action to log in to the Container registry registry using the account and password that will publish the packages. Once published, the packages are scoped to the account defined here.
      - name: Log in to the Container registry
        uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      # This step uses [docker/metadata-action](https://github.com/docker/metadata-action#about) to extract tags and labels that will be applied to the specified image. The `id` "meta" allows the output of this step to be referenced in a subsequent step. The `images` value provides the base name for the tags and labels.
      - name: Extract metadata (tags, labels) for Docker
        id: meta
        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
      # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.
      # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see "[Usage](https://github.com/docker/build-push-action#usage)" in the README of the `docker/build-push-action` repository.
      # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
      - name: Build and push Docker image
        id: push
        uses: docker/build-push-action@f2a1d5e99d037542a71f64918e516c093c6f3fc4
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
      
      # This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see "[AUTOTITLE](/actions/security-guides/using-artifact-attestations-to-establish-provenance-for-builds)." 
      - name: Generate artifact attestation
        uses: actions/attest-build-provenance@v1
        with:
          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
          subject-digest: ${{ steps.push.outputs.digest }}
          push-to-registry: true
      

name: Create and publish a Docker image

on:
  push:
    branches: ['release']

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  build-and-push-image:
    runs-on: ubuntu-latest

    permissions:
      contents: read
      packages: write
      attestations: write
      id-token: write

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Log in to the Container registry
        uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Extract metadata (tags, labels) for Docker
        id: meta
        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}

      - name: Build and push Docker image
        id: push
        uses: docker/build-push-action@f2a1d5e99d037542a71f64918e516c093c6f3fc4
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}

      - name: Generate artifact attestation
        uses: actions/attest-build-provenance@v1
        with:
          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
          subject-digest: ${{ steps.push.outputs.digest }}
          push-to-registry: true

#
name: Create and publish a Docker image

# Configures this workflow to run every time a change is pushed to the branch called `release`.
on:
  push:
    branches: ['release']

# Defines two custom environment variables for the workflow. These are used for the Container registry domain, and a name for the Docker image that this workflow builds.
env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

# There is a single job in this workflow. It's configured to run on the latest available version of Ubuntu.
jobs:
  build-and-push-image:
    runs-on: ubuntu-latest
    # Sets the permissions granted to the `GITHUB_TOKEN` for the actions in this job.
    permissions:
      contents: read
      packages: write
      attestations: write
      id-token: write
      # 
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      # Uses the `docker/login-action` action to log in to the Container registry registry using the account and password that will publish the packages. Once published, the packages are scoped to the account defined here.
      - name: Log in to the Container registry
        uses: docker/login-action@65b78e6e13532edd9afa3aa52ac7964289d1a9c1
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      # This step uses [docker/metadata-action](https://github.com/docker/metadata-action#about) to extract tags and labels that will be applied to the specified image. The `id` "meta" allows the output of this step to be referenced in a subsequent step. The `images` value provides the base name for the tags and labels.
      - name: Extract metadata (tags, labels) for Docker
        id: meta
        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
      # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.
      # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see "[Usage](https://github.com/docker/build-push-action#usage)" in the README of the `docker/build-push-action` repository.
      # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
      - name: Build and push Docker image
        id: push
        uses: docker/build-push-action@f2a1d5e99d037542a71f64918e516c093c6f3fc4
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
      
      # This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see "[AUTOTITLE](/actions/security-guides/using-artifact-attestations-to-establish-provenance-for-builds)." 
      - name: Generate artifact attestation
        uses: actions/attest-build-provenance@v1
        with:
          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
          subject-digest: ${{ steps.push.outputs.digest }}
          push-to-registry: true
      

Dieser neue Workflow wird jedes Mal automatisch ausgeführt, wenn du eine Änderung an einem Branch mit dem Namen release im Repository pushst. Auf der Registerkarte Aktionen kannst du den Fortschritt nachverfolgen.

Ein paar Minuten nach Abschluss des Workflows wird das neue Paket in Ihrem Repository angezeigt. Weitere Informationen zum Suchen deiner verfügbaren Pakete findest du unter Pakete anzeigen.

Installieren eines Pakets mithilfe einer Aktion

Du kannst Pakete als Teil deines CI-Flows mithilfe von GitHub Actions erstellen. Beispielsweise kannst du einen Workflow konfigurieren. Jedes Mal, wenn eine Entwicklerin Code an einen Pull Request pusht, löst der Workflow die Abhängigkeiten auf, indem er Pakete herunterlädt und installiert, die von GitHub Packages gehostet werden. Anschließend kann der Workflow CI-Tests ausführen, die die Abhängigkeiten erfordern.

Die Installation von Paketen, die von GitHub Packages über GitHub Actions gehostet werden, erfordert eine minimale Konfiguration oder zusätzliche Authentifizierung, wenn du GITHUB_TOKEN verwendest. Datenübertragungen sind auch kostenlos, wenn eine Aktion ein Paket installiert. Weitere Informationen findest du unter Informationen zur Abrechnung für GitHub Packages.

Die Konfigurationsschritte variieren je nach Paketclient. Allgemeine Informationen zum Konfigurieren eines Workflows für GitHub Actions findest du unter Schreiben von Workflows.

Upgraden eines Workflows, der ein personal access token für den Zugriff auf eine Registrierung verwendet

GitHub Packages unterstützt das GitHub-Token (GITHUB_TOKEN) für eine einfache und sichere Authentifizierung in deinen Workflows. Wenn du eine Registrierung verwendest, die differenzierte Berechtigungen unterstützt, und dein Workflow ein personal access token zum Authentifizieren bei einer Registrierung verwendet, solltest du deinen Workflow unbedingt aktualisieren, um das GitHub-Token (GITHUB_TOKEN) zu verwenden.

Weitere Informationen zum GITHUB_TOKEN findest du unter Automatische Tokenauthentifizierung.

Wenn du das GitHub-Token (GITHUB_TOKEN) verwendest anstatt ein personal access token (classic) mit dem Bereich repo, erhöht sich die Sicherheit deines Repositorys, da du kein langlebiges personal access token verwenden musst, das unnötigen Zugriff auf das Repository bietet, in dem dein Workflow ausgeführt wird. Weitere Informationen zu bewährten Methoden für die Sicherheit findest du unter Sicherheitshärtung für GitHub Actions.

1. Navigiere zur Landing Page deines Pakets.

2. Um sicherzustellen, dass dein Paket Zugriff auf deinen Workflow hat, musst du das Repository hinzufügen, in dem der Workflow für dein Paket gespeichert ist. Wähle unter „Zugriff auf Actions verwalten“ Repository hinzufügen aus, und suche nach dem Repository, das du hinzufügen möchtest.

   

Dieser Workflow veröffentlicht beispielsweise ein Docker-Image in der Container registry und verwendet ${{ secrets.GITHUB_TOKEN }} für die Authentifizierung. Weitere Informationen findest du unter Einrichten automatisierter Builds in der Docker-Dokumentation.

#
name: Demo Push

# This workflow runs when any of the following occur:
# - A push is made to a branch called `main` or `seed`
# - A tag starting with "v" is created
# - A pull request is created or updated
on:
  push:
    branches:
      - main
      - seed
    tags:
      - v*
  pull_request:
  # This creates an environment variable called `IMAGE_NAME ` with the value `ghtoken_product_demo`.
env:
  IMAGE_NAME: ghtoken_product_demo
#
jobs:
  # This pushes the image to GitHub Packages.
  push:
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
      #
    steps:
      - uses: actions/checkout@v4

      - name: Build image
        run: docker build . --file Dockerfile --tag $IMAGE_NAME --label "runnumber=${GITHUB_RUN_ID}"

      - name: Log in to registry
        run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin
        #
      - name: Push image
        run: |
          IMAGE_ID=ghcr.io/${{ github.repository_owner }}/$IMAGE_NAME

          # This changes all uppercase characters to lowercase.
          IMAGE_ID=$(echo $IMAGE_ID | tr '[A-Z]' '[a-z]')
          # This strips the git ref prefix from the version.
          VERSION=$(echo "${{ github.ref }}" | sed -e 's,.*/\(.*\),\1,')
          # This strips the "v" prefix from the tag name.
          [[ "${{ github.ref }}" == "refs/tags/"* ]] && VERSION=$(echo $VERSION | sed -e 's/^v//')
          # This uses the Docker `latest` tag convention.
          [ "$VERSION" == "main" ] && VERSION=latest
          echo IMAGE_ID=$IMAGE_ID
          echo VERSION=$VERSION
          docker tag $IMAGE_NAME $IMAGE_ID:$VERSION
          docker push $IMAGE_ID:$VERSION

name: Demo Push

on:
  push:
    branches:
      - main
      - seed
    tags:
      - v*
  pull_request:

env:
  IMAGE_NAME: ghtoken_product_demo

jobs:

  push:
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read

    steps:
      - uses: actions/checkout@v4
      - name: Build image
        run: docker build . --file Dockerfile --tag $IMAGE_NAME --label "runnumber=${GITHUB_RUN_ID}"
      - name: Log in to registry
        run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin

      - name: Push image
        run: |
          IMAGE_ID=ghcr.io/${{ github.repository_owner }}/$IMAGE_NAME

          IMAGE_ID=$(echo $IMAGE_ID | tr '[A-Z]' '[a-z]')

          VERSION=$(echo "${{ github.ref }}" | sed -e 's,.*/\(.*\),\1,')

          [[ "${{ github.ref }}" == "refs/tags/"* ]] && VERSION=$(echo $VERSION | sed -e 's/^v//')

          [ "$VERSION" == "main" ] && VERSION=latest
          echo IMAGE_ID=$IMAGE_ID
          echo VERSION=$VERSION
          docker tag $IMAGE_NAME $IMAGE_ID:$VERSION
          docker push $IMAGE_ID:$VERSION

#
name: Demo Push

# This workflow runs when any of the following occur:
# - A push is made to a branch called `main` or `seed`
# - A tag starting with "v" is created
# - A pull request is created or updated
on:
  push:
    branches:
      - main
      - seed
    tags:
      - v*
  pull_request:
  # This creates an environment variable called `IMAGE_NAME ` with the value `ghtoken_product_demo`.
env:
  IMAGE_NAME: ghtoken_product_demo
#
jobs:
  # This pushes the image to GitHub Packages.
  push:
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
      #
    steps:
      - uses: actions/checkout@v4

      - name: Build image
        run: docker build . --file Dockerfile --tag $IMAGE_NAME --label "runnumber=${GITHUB_RUN_ID}"

      - name: Log in to registry
        run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin
        #
      - name: Push image
        run: |
          IMAGE_ID=ghcr.io/${{ github.repository_owner }}/$IMAGE_NAME

          # This changes all uppercase characters to lowercase.
          IMAGE_ID=$(echo $IMAGE_ID | tr '[A-Z]' '[a-z]')
          # This strips the git ref prefix from the version.
          VERSION=$(echo "${{ github.ref }}" | sed -e 's,.*/\(.*\),\1,')
          # This strips the "v" prefix from the tag name.
          [[ "${{ github.ref }}" == "refs/tags/"* ]] && VERSION=$(echo $VERSION | sed -e 's/^v//')
          # This uses the Docker `latest` tag convention.
          [ "$VERSION" == "main" ] && VERSION=latest
          echo IMAGE_ID=$IMAGE_ID
          echo VERSION=$VERSION
          docker tag $IMAGE_NAME $IMAGE_ID:$VERSION
          docker push $IMAGE_ID:$VERSION