So integrieren Sie die JFrog Platform nahtlos mit Ihrer GitHub-Umgebung

Leitfaden zur Integration Ihrer GitHub- und JFrog-Plattformen für eine einheitliche Verwaltung und Sicherung von Softwareprojekten während der Codierungs- und Erstellungsphase.

GitHub JFrog Integration

Durch die neue JFrog-Partnerschaft mit GitHub können Sie Ihre bevorzugten Lösungen für Quellcode und Binärdateien in einer nahtlosen Integration kombinieren. Profitieren Sie von einer einheitlichen, umfassenden und sicheren End-to-End-Umgebung für Ihre Softwareprojekte.

Die Integration deckt alles ab, angefangen von der Kuratierung von Open-Source-Paketen über die Codierung, CI und Release-Management bis hin zur Bereitstellung und Produktion. Sie können dadurch die Entwicklererfahrung in drei wesentlichen Bereichen optimieren.

  1. Einheitliche Authentifizierung und Autorisierung: Schützen Sie Ihren GitHub-Workflow und ermöglichen Sie die nahtlose SSO-Authentifizierung zwischen JFrog und GitHub.
  2. Bidirektionale Code- und Paketverknüpfung: Verknüpfen Sie Code und Pakete plattformübergreifend.
  3. Einheitliche Sicherheit: JFrog Advanced Security-Ergebnisse sind direkt über das GitHub-Dashboard verfügbar und die bei Zusammenführungen durchgeführten Pull-Anfragen werden überprüft.

Flow chart demonstrating how GitHub and JFrog interact throughout the software development lifecycle.

Einheitliche End-to-End-Erfahrung mit JFrog und GitHub vom Code bis zum Paket

In diesem Blogbeitrag erläutern wir den Workflow von Anwendungsfällen, einschließlich Schritt-für-Schritt-Anweisungen für die Integration.

Fangen wir an!

Bevor Sie loslegen

Folgende Voraussetzungen müssen erfüllt sein:

1. Authentifizierung und Autorisierung

Konfigurieren Sie für die Authentifizierung und Autorisierung auf beiden Plattformen Folgendes:

GitHub-Variablen

GitHub-Variablen dienen zum Speichern Ihrer sensiblen Authentifizierung. Definieren Sie die folgenden beiden Variablen in GitHub, um auf JFrog zu verweisen. Fügen Sie Ihre Variablen unter Einstellungen > Geheimnisse und Variablen > Aktionen hinzu.

  • JF_URL: steht für die Basis-URL zum JFrog-Server
  • JF_PROJECT: steht für den JFrog-Projektschlüssel für die Verbindung mit dem GitHub-Repository

Aktionen, Geheimnisse und Variablen in GitHub

Zurück zum Anfang >

OAuth

Konfigurieren Sie OAuth für die Anmeldung auf der JFrog Platform basierend auf der GitHub-Authentifizierung GitHub OAuth.

GitHub OAuth Login to the JFrog PlatformAnmeldung auf der JFrog Platform mit GitHub OAuth

Zurück zum Anfang >

OIDC

Durch die JFrog-Integration von OIDC mit GitHub-Aktionen können Sie eine vertrauenswürdige Beziehung zwischen Ihren GitHub-Aktionen und der JFrog Platform herstellen.

Klicken Sie auf der JFrog Platform auf die Registerkarte „Administration“ und wählen Sie Allgemein > Integrationen verwalten > Neue Integration > OpenID Connect .

Konfigurieren Sie die OIDC-Integration und klicken Sie auf Speichern und anschließend auf „Weiter“.

Konfigurieren Sie die Identitätszuordnung:

  • Name: Name der Identitätszuordnungen
  • Beschreibung: nach Möglichkeit Angaben zum ursprünglichen Repository und zur zugeordneten Identität
  • Priorität: Reihenfolge, in der die Identitätszuordnungen ausgewertet werden
  • Claims json: JSON-Datei mit allen zu prüfenden Ansprüchen, um die Zuordnung als „true“ zu bewerten
    • iss: auf https://token.actions.githubusercontent.com festlegen, um zu verifizieren, dass Claims von GitHub erstellt wurden
    • Unternehmen: optionale Claims-Einschränkung für das Unternehmen, zu dem das Repository gehört
    • Repository: der Name Ihres GitHub-Repositorys
    • Optionale Claims: environment, actor, runner_environment, sub, repository_owner, repository_visibility, workflow und mehr
      Beispiel:

      {"repository":"<repository_name>, "enterprise":"<your_github_enterprise_name>"}
  • Token-Umfang: Gruppe/Benutzer/Admin: Token für eine bestimmte Gruppe oder einen bestimmten Benutzer
  • Dienst: spezielle oder alle JFrog-Dienste, um den Zugriff zu ermöglichen
  • Gültigkeitszeitraum des Tokens: Anzahl der Minuten bis zum Ablauf des Tokens

JFrog Platform - Identity MappingIdentitätszuordnung auf der JFrog Platform

JFrog Platform and GitHub - OIDC IntegrationJFrog Platform und GitHub – OIDC-Integration

Zurück zum Anfang >

GitHub-Aktionen

Konfigurieren Sie die GitHub-Aktion, um JFrog CLI einzurichten und JFrog FrogBot auszuführen.

Konfigurieren Sie JFrog CLI:

- name: Setup JFrog CLI
    uses: jfrog/setup-jfrog-cli@v4
    env: 
      JF_URL: https://${{ vars.JF_URL }}/
      JF_PROJECT: ${{ vars.JF_PROJECT }}
    with:
      oidc-provider-name: <OIDC integration name set on JFrog platform>

Konfigurieren Sie Frogbot:

 - uses: jfrog/frogbot@v2
      with:
          oidc-provider-name: 
env:
          # JFrog platform URL
          JF_URL: https://${{ vars.JF_URL }}/
          JF_PROJECT: ${{ vars.JF_PROJECT }}
          JF_GIT_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          …

Zurück zum Anfang >

2. Bidirektionale Code- und Paketverknüpfung

Indem Sie JFrog CLI in Ihrer GitHub-Build-Aktion verwenden, wird der Build mit relevanten Build-Informationen, Paketen und Sicherheitsscans in JFrog verknüpft. Durch diese Integration können Sie GitHub-Aktionen und JFrog Artifactory kombinieren.

In dieser YML-Beispieldatei ist der Build für die automatische Auslösung nach jeder Pull-Anfrage und jedem Push konfiguriert.

 # setting python to use a curated python repository
- name: configure jfrog environment
    run: |
      jf pip-config --repo-resolve=python-virtual 
# configuring python
- name: configure environment
              run: |                      
                python3 -m pip install --upgrade pip setuptools wheel sigstore
                wheel -h
                pip show setuptools
                echo $VIRTUAL_ENV
# building the python package
- name: build project
    run: |                      
      jf pip install -r requirements.txt
python setup.py sdist bdist_wheel
cd dist && echo "hashes=$(sha256sum * | base64 -w0)" >> $GITHUB_OUTPUT

# uploading the python package int the JFrog platform
- name: publish python package
    run: |
      jf rt upload dist/ python-virtual/example-projects/ 

# setting docker
- name: Setup Docker Buildx
  uses: docker/setup-buildx-action@v3

# docker authentication using the oidc short lived credentials
- name: Authenticate Docker
    uses: docker/login-action@v3
    with:
      registry: ${{ vars.JF_URL }}
      username: ${{ steps.setup-cli.outputs.oidc-user }}
      password: ${{ steps.setup-cli.outputs.oidc-token }}
# docker image build
- name: Build Docker image
    uses: docker/build-push-action@v5
    id: build
    with:
      push: true
      platforms: linux/amd64 #, linux/arm64
      tags: ${{ vars.JF_URL }}/${{ env.DOCKER_REPO }}/${{ env.IMAGE_NAME }}
# docker xray scanning
- name: docker scan
     run: |  
       jf docker pull ${{ vars.JF_URL }}/${{ env.DOCKER_REPO }}/${{ env.IMAGE_NAME }}
       jf docker scan ${{ vars.JF_URL }}/${{ env.DOCKER_REPO }}/${{ env.IMAGE_NAME }} 

# adding the built docker into the JFrog build info
- name: add docker package to build
    run: |  
      echo "${{ vars.JF_URL }}/${{ env.DOCKER_REPO }}/${{ env.IMAGE_NAME }}@${{ steps.build.outputs.digest }}" > metadata.json
      jf rt build-docker-create ${{ env.DOCKER_REPO }} --image-file metadata.json 

# publishing and scanning a build info for the build
- name: publish build info
    run: |
      jf rt build-collect-env      # Collect environment variables
      jf rt build-publish       # Publish build info
      jf build-scan  # Xray Scan Build info

JFrog-Jobzusammenfassung in GitHub

Nach der Ausführung des Builds wird eine Jobzusammenfassung mit den Build- und Sicherheitsinformationen generiert. Sie können einfach zwischen der JFrog- und GitHub-Plattform navigieren. Auf diese Weise können Sie die Daten des Xray-Sicherheitsscans, Build-Details wie Build-Unterschiede, Umgebungsvariablen, JSON-Informationen und vieles mehr anzeigen. Zusätzliche Informationen zu Ihren Artefakten und Ihrem Sicherheitsscan erhalten Sie, indem Sie auf den Projektpaket-Link klicken, um die JFrog-Projektpaketansicht aufzurufen.

JFrog Job Summary, and Build-Info SBOM pointing back to GitHub JobJFrog-Jobzusammenfassung, Pakete, Schwachstellen und SBOM (Software Bill of Materials) des Builds für den GitHub-Job

3. Einheitliche Sicherheit

JFrog Frogbot scannt Ihre Repositories automatisch auf potenzielle Schwachstellen, offengelegte Geheimnisse und Malware in Ihren Abhängigkeiten. Wenn Schwachstellen entdeckt werden, warnt Frogbot Sie nicht nur, sondern kann auch automatisch Pull-Anfragen mit Korrekturvorschlägen öffnen, um die Fehlerbehebung zu optimieren. Diese Überprüfungen können verhindern, dass nicht autorisierte oder riskante Codeänderungen in Ihr Repository übernommen werden.

Detaillierte Berichte und Dashboard-Ansichten geben zudem Auskunft über den Sicherheitsstatus Ihrer Projekte und erleichtern die Einhaltung von Compliance-Anforderungen.

Frogbot mit GitHub einrichten >

Unsafe Hash Algorithm

 

In diesem Beispiel hat Frogbot einen unsicheren Hash-Algorithmus erkannt:

Eine solche Schwachstelle tritt bei Verwendung eines als unsicher bekannten Hash-Algorithmus auf.
Hash-Algorithmen akzeptieren beliebige Eingaben und generieren einen Hash-Wert – eine Ausgabe mit einer festen Länge.
Anhand dieser Ausgabe kann die Integrität von Daten wie Passwörtern oder Dateien verifiziert werden.
Unsichere Hash-Algorithmen können von Angreifern genutzt werden, um
innerhalb des erforderlichen Zeitrahmens denselben Hash-Wert für andere Eingabedaten zu generieren
und einen „Kollisionsangriff“ durchzuführen.

Das Problem kann wie folgt behoben werden:

Remediation

Das war’s!

Jetzt können Sie es einfach selbst ausprobieren.

 

Nehmen Sie am gemeinsamen Webinar von GitHub und JFrog am 13. Juni teil.

Für Webinar registrieren