Comment connecter la Plateforme JFrog à votre environnement GitHub pour créer une intégration fluide

Guide d’intégration de vos plateformes GitHub et JFrog, offrant une expérience unifiée pour la gestion et la sécurisation des projets logiciels tout au long des phases de codage et de création.

GitHub JFrog Integration

La dernière collaboration entre JFrog et GitHub vous permet d’associer facilement vos solutions préférées pour le code source et les fichiers binaires, dans une intégration fluide. Ainsi, vous bénéficiez désormais d’une expérience intégrale, unifiée, complète et sécurisée, pour prendre en charge vos projets logiciels.

Cette intégration couvre aussi bien les packages open source que le codage, le CI, la gestion des publications, le déploiement et la production. Vous bénéficiez également de trois améliorations majeures pour votre expérience de développeur.

  1. Authentification et autorisation unifiées – pour les actions de workflow GitHub et pour une authentification de SSO fluide entre JFrog et GitHub.
  2. Code bidirectionnel et association de package – Le code et les packages sont associés sur les deux plateformes.
  3. Sécurité unifiée – Les détections de JFrog Advanced Security sont disponibles directement dans le tableau de bord GitHub, et extraient les contrôles de requêtes effectués sur les fusions.

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

Expérience intégrale et unifiée JFrog et GitHub, du code au package

Dans cet article de blog, nous allons passer en revue les flux de cas d’utilisation, avec notamment des instructions étape par étape pour démontrer l’intégration.

C’est parti !

Avant de commencer

Voici ce dont vous aurez besoin :

1. Authentification et autorisation

Pour obtenir l’authentification et l’autorisation sur les deux plateformes, vous devez configurer :

Des variables Github

Les variables GitHub servent à stocker vos informations sensibles. Définissez les deux variables suivantes dans GitHub, qui pointeront vers JFrog. Accédez à Settings (Paramètres) > Secrets and variables (Secrets et variables) > Actions, puis ajoutez vos variables.

  • JF_URL – représente l’URL de base sur le serveur JFrog
  • JF_PROJECT – représente la clé du projet JFrog qui se connecte au dépôt GitHub

Secrets et variables des actions GitHub

Retour en haut >

OAuth

Configurez OAuth pour vous connecter à la Plateforme JFrog d’après l’authentification GitHub GitHub OAuth.

GitHub OAuth Login to the JFrog PlatformConnexion GitHub OAuth à la Plateforme JFrog

Retour en haut >

OIDC

L’intégration par JFrog d’OIDC avec GitHub Actions vous permet d’établir une relation de confiance entre GitHub Actions et la Plateforme JFrog.

À partir de l’UI de la Plateforme JFrog, accédez à l’onglet Administration > General (Général) > Manage Integrations (Gérer les intégrations) > New Integration (Nouvelle intégration) > OpenID Connect.

Configurez l’intégration OIDC, puis cliquez sur Save (Enregistrer) et Continue (Continuer).

Configurez le mappage d’identité :

  • Name (Nom) : nom des mappages d’identité
  • Description : de préférence, doit identifier le dépôt d’origine et l’identité mappée
  • Priority (Priorité) : ordre de priorité selon lequel les mappages d’identité sont évalués
  • Claims json (Affirmations json) : un fichier JSON contenant toutes les affirmations à vérifier pour que ce mappage soit évalué comme vrai
    • iss : défini sur https://token.actions.githubusercontent.com pour vérifier que les affirmations ont été produites par Github
    • Enterprise (Entreprise) : restriction des affirmations facultative pour le nom d’entreprise auquel appartient le dépôt
    • Repository (Dépôt) : le nom de votre dépôt Github
    • Optional claims (Affirmations facultatives) : environment, actor, runner_environment, sub, repository_owner, repository_visibility, workflow, etc.
      Par exemple,

      {"repository":"<repository_name>, "enterprise":"<your_github_enterprise_name>"}
  • Token scope (Portée du jeton) : Groupe / Utilisateur / Administrateur : jeton dont la portée est délimitée avec un groupe/utilisateur spécifique
  • Service : services JFrog spécifiques/tous les services JFrog pour permettre l’accès
  • Token Expiration Time (Délai d’expiration du jeton) : nombre de minutes avant l’expiration du jeton

JFrog Platform - Identity MappingPlateforme JFrog – Mappage d’identité

JFrog Platform and GitHub - OIDC IntegrationPlateforme JFrog et GitHub – Intégration OIDC

Retour en haut >

GitHub Actions

Créez votre configuration Github Action pour définir JFrog CLI et exécuter JFrog FrogBot.

Définir la configuration JFrog CLI :

- name: Configurer JFrog CLI
    utilise : jfrog/setup-jfrog-cli@v4
    env: 
      JF_URL : https://${{ vars.JF_URL }}/
      JF_PROJECT : ${{ vars.JF_PROJECT }}
    avec :
      oidc-provider-name : <nom de l'intégration OIDC définie sur la Plateforme JFrog>

Configuration de Frogbot :

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

Retour en haut >

2. Association de package et code bidirectionnel

L’utilisation de JFrog CLI dans votre action de build GitHub connecte le build aux informations de build pertinentes, aux packages et aux scans de sécurité dans JFrog. Cette intégration vous permet de combiner GitHub Actions et JFrog Artifactory.

Cet exemple de tâche de build yml est configuré pour se déclencher automatiquement après chaque requête d’extraction/d’envoi.

 # configuration de python pour utiliser un dépôt python organisé
- name: configurer l’environnement jfrog
    run: |
      jf pip-config --repo-resolve=python-virtual 
# configuration de python
- name: configurer l’environnement
              run: |                      
                python3 -m pip install --upgrade pip setuptools wheel sigstore
                wheel -h
                pip show setuptools
                echo $VIRTUAL_ENV
# création du package python
- name: projet de build
    run: |                      
      jf pip install -r requirements.txt
python setup.py sdist bdist_wheel
cd dist && echo "hashes=$(sha256sum * | base64 -w0)" >> $GITHUB_OUTPUT

# téléverser le package python sur la Plateforme JFrog
- name: publier un package python
    run: |
      jf rt upload dist/ python-virtual/example-projects/ 

# définition de Docker
- name: Configurer Docker Buildx
  utilise : docker/setup-buildx-action@v3

# authentification docker à l’aide des identifiants de courte durée oidc
- name: Authentifier Docker
    utilise : docker/login-action@v3
    avec :
      registre : ${{ vars.JF_URL }}
      nom d'utilisateur : ${{ steps.setup-cli.outputs.oidc-user }}
      mot de passe : ${{ steps.setup-cli.outputs.oidc-token }}
# build d'image de docker
- name: Créer une image Docker
    utilise : docker/build-push-action@v5
    id : build
    avec :
      envoi : vrai
      plateformes : linux/amd64 #, linux/arm64
      étiquettes : ${{ vars.JF_URL }}/${{ env.DOCKER_REPO }}/${{ env.IMAGE_NAME }}
# scan docker xray
- name: scan docker
     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 }} 

# ajout du docker conçu dans les informations de build de JFrog
- name: ajouter un package docker au 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 

# publication et scan d’une information de build pour le build
- name: publier les informations du build
    run: |
      jf rt build-collect-env      # Collecter les variables d'environnement
      jf rt build-publish       # Publier les informations de build
      jf build-scan  # Informations de build de scan Xray

Résumé de la tâche JFrog dans GitHub

Une fois l’exécution du build terminée, un résumé de la tâche qui inclut les informations de build et de sécurité est généré. Vous pouvez facilement naviguer vers et depuis les plateformes JFrog et GitHub. Vous pouvez ainsi consulter les données de scan de sécurité Xray, les détails du build du projet tels que le diff de build, les variables d’environnement, les informations json de build, et bien plus encore. Vous pouvez également obtenir des informations supplémentaires sur vos artefacts et votre scan de sécurité en cliquant sur le lien du package de projet, qui vous dirigera vers la vue des packages de projet JFrog.

JFrog Job Summary, and Build-Info SBOM pointing back to GitHub JobRésumé de tâche JFrog, packages, vulnérabilités et informations sur le build SBOM pointant vers la tâche GitHub

3. Sécurité unifiée

JFrog Frogbot scanne automatiquement vos dépôts pour détecter les vulnérabilités potentielles, les secrets exposés et les malwares dans vos dépendances. Lorsque des vulnérabilités sont détectées, Frogbot vous avertit et peut également ouvrir automatiquement des demandes de d’extraction avec des correctifs suggérés, ce qui rationalise le processus de correction. Ces vérifications peuvent éviter que toute modification de code non autorisée ne soit fusionnée dans votre dépôt.

Vous bénéficiez également de rapports et de tableaux de bord détaillés qui peuvent vous aider à répondre aux exigences de conformité et donner un aperçu de la posture de sécurité de vos projets.

Configuration Frogbot avec des actions GitHub >

Unsafe Hash Algorithm

 

Dans cet exemple, nous pouvons voir que Frogbot a détecté un algorithme de hachage non sécurisé :

Une vulnérabilité d’algorithme de hachage non sécurisé se produit lors de l’utilisation d’un algorithme de hachage non sécurisé connu.
Un algorithme de hachage accepte une entrée arbitraire et génère une valeur de hachage, une sortie à longueur fixe
qui peut être utilisée pour vérifier l’intégrité des données, comme les mots de passe ou les fichiers.
Un algorithme de hachage non sécurisé dans un algorithme qu’un attaquant peut utiliser pour générer
la même valeur de hachage pour différentes données d’entrée dans un délai raisonnable
(« attaque de collision de hachage »).

La correction suivante a également été fournie pour nous aider à résoudre facilement le problème :

Remediation

Voilà !

Maintenant, il ne vous reste plus qu’à essayer.

 

Découvrez la puissance de l’association de GitHub et JFrog le 13 juin.

Inscrivez-vous à notre webinaire commun