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

Die neue Zusammenarbeit von JFrog mit GitHub ermöglicht es Ihnen, Ihre bevorzugten Lösungen für Source Code und Binaries in einer nahtlosen Integration zu kombinieren. Das heißt, Sie haben jetzt eine einheitliche, übergreifende und sichere End-to-End-Erfahrung, die Ihre Softwareprojekte unterstützt.

Diese Integration deckt alles ab, von der Kuratierung von Open-Source-Paketen über Coding, CI, Release Management, Deployment und Produktion. Dazu gehören drei wichtige Verbesserungen für Ihre Entwicklererfahrung.

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: Code und Pakete können über beide Plattformen hinweg verknüpft werden.
3. Einheitliche Sicherheit: JFrog Advanced Security-Ergebnisse sind direkt aus dem GitHub-Dashboard verfügbar, und bei Merges werden Pull-Requests überprüft.

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:

• JFrog Platform-Cloud
  • Erstellen Sie ein JFrog-Projekt namens CodeNinjas_AI
• Beispiel eines GitHub-Repositorys
  • Forken Sie dieses Beispiel-Repository, damit Sie Ihre eigene Kopie zum Ausprobieren haben.

1. Authentifizierung und Autorisierung

Um die Authentifizierung und Autorisierung über beide Plattformen hinweg zu erhalten, müssen Sie folgendes konfigurieren:

• GitHub-Variablen
• OAuth
• OIDC
• GitHub-Aktionen

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.

Anmeldung 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-Actions 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 das Identity Mapping:

• Name: Name des Identity Mappings
• Beschreibung: nach Möglichkeit Angaben zum ursprünglichen Repository und zur zugeordneten Identität
• Priorität: Reihenfolge, in der die Identity Mappings ausgewertet werden
• Claims json: JSON-Datei mit allen zu prüfenden Claims, 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-Services, denen Zugriff gegeben werden soll
• Gültigkeitszeitraum des Tokens: Anzahl der Minuten bis zum Ablauf des Tokens

Identity Mapping auf der JFrog Plattform

JFrog Platform und GitHub – OIDC-Integration

Zurück zum Anfang >

GitHub-Actions

Konfigurieren Sie die GitHub-Action, 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-Action verwenden, wird der Build mit relevanten Build-Informationen, Paketen und Sicherheitsscans in JFrog verknüpft. Durch diese Integration können Sie GitHub-Actions 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-Job-Übersicht in GitHub

Nach der Ausführung des Builds wird eine Job-Übersicht 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-Übersicht , 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, Exposed Secrets 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 Checks 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 >

 

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 daraus 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 so einen „Kollisionsangriff“ durchzuführen.

Das Problem kann wie folgt behoben werden:

Das war’s!

Probieren Sie es selbst aus!

 

Seien Sie dabei, beim gemeinsamen Webinar von GitHub und JFrog am 13.Juni!

Für Webinar registrieren