Accédez aux ressources d'un environnement JFrog Artifactory privé avec des pools privés

Cette page explique comment utiliser des pools privés Cloud Build pour accéder aux ressources d'un réseau cloud privé virtuel privé.

Dans ce tutoriel, vous allez créer un Artifactory JFrog dans Compute Engine hébergé sur un réseau VPC privé, puis configurer une compilation exécutée dans un pool privé pour accéder aux données de cet Artifactory. Jfrog Artifactory est un gestionnaire de dépôts binaires Open Source.

Objectifs

  • Configurer un Artifactory Jfrog sur Compute Engine
  • Importer un fichier dans l'Artifactory
  • Créer un pool privé
  • Appairer le réseau de producteurs de services qui héberge le pool privé au réseau cloud privé virtuel de l'Artifactory
  • Écrire un fichier de configuration de compilation pour accéder aux données de l'Artifactory

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

  • Compute Engine
  • Cloud Build

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud.

  4. Activer les API Compute Engine, Cloud Build, Service Networking.

    Activer les API

    5.

  5. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  6. Vérifiez que la facturation est activée pour votre projet Google Cloud.

  7. Activer les API Compute Engine, Cloud Build, Service Networking.

    Activer les API

    8.

Option A : Utiliser Cloud Shell

Vous pouvez suivre ce tutoriel avec Cloud Shell, qui est préinstallé avec la Google Cloud CLI utilisée dans ce tutoriel. Si vous utilisez Cloud Shell, vous n'avez pas besoin d'installer ces outils de ligne de commande sur votre poste de travail.

Pour utiliser Cloud Shell, procédez comme suit :

  1. Accédez à Google Cloud Console.

    Console Google Cloud

  2. Cliquez sur le bouton Activer Cloud Shell en haut de la fenêtre de la console Google Cloud.Bouton d'activation de Cloud Shell

    Une session Cloud Shell s'ouvre dans un nouveau cadre en bas de la console Google Cloud et affiche une invite de ligne de commande.

    Session Cloud Shell

Option B : Utiliser des outils de ligne de commande localement

Si vous préférez suivre ce tutoriel sur votre poste de travail, suivez les étapes ci-dessous pour installer les outils nécessaires.

  1. Installez la Google Cloud CLI.

Créer l'Artifactory privé

  1. Créez une instance Compute Engine à partir d'un conteneur :

    gcloud compute instances create-with-container jfrog \
--container-image docker.bintray.io/jfrog/artifactory-jcr:latest \
--zone us-central1-a

  2. Vous connecter en SSH à l'instance L'initialisation du conteneur peut prendre quelques minutes.

    gcloud compute ssh --zone us-central1-a jfrog

  3. Testez la connexion en exécutant la commande suivante. Une fois le conteneur prêt, il renvoie un code HTTP 200 suivi d'une page HTML.

    curl -i http://localhost:8081

  4. Pour créer un dépôt dans l'Artifactory, vous devez signer le CLUF (contrat de licence de l'utilisateur final) de JFrog :

    curl -XPOST -vu admin:password http://localhost:8081/artifactory/ui/jcr/eula/accept

    Un résultat semblable aux lignes suivantes s'affiche :

        *   Trying 127.0.0.1:8081...
    * Connected to localhost (127.0.0.1) port 8081 (#0)
    * Server auth using Basic with user 'admin'
    > POST /artifactory/ui/jcr/eula/accept HTTP/1.1
    > Host: localhost:8081
    > Authorization: Basic ….
    > User-Agent: curl/7.74.0
    > Accept: */*
    >
    * Mark bundle as not supporting multiuse
    < HTTP/1.1 200 OK
    < X-JFrog-Version: Artifactory/7.19.9 71909900
    < X-Artifactory-Id: ….
    < X-Artifactory-Node-Id: jfrog2
    < SessionValid: false
    < Content-Length: 0
    < Date: Fri, 25 Jun 2021 19:08:10 GMT

    * Connection #0 to host localhost left intact

Importer un fichier dans l'Artifactory

  1. Créez un fichier .txt à importer dans l'Artifactory :

    echo "Hello world" >> helloworld.txt

  2. JFrog est fourni avec un exemple de dépôt par défaut. Importez le fichier dans le dépôt à l'aide des identifiants par défaut :

    curl -u admin:password -X PUT \
"http://localhost:8081/artifactory/example-repo-local/helloworld.txt" \
-T helloworld.txt

    Cette opération devrait renvoyer les valeurs ci-dessous :

        {
    "repo" : "example-repo-local",
    "path" : "/helloworld.txt",
    "created" : "2021-06-25T19:08:24.176Z",
    "createdBy" : "admin",
    "downloadUri" : "http://localhost:8081/artifactory/example-repo-local/helloworld.txt",
    "mimeType" : "text/plain",
    "size" : "12",
    "checksums" : {
      "sha1" : "...",
      "md5" : "...",
      "sha256" : "..."
    },
    "originalChecksums" : {
      "sha256" : "..."
    },
    "uri" : "http://localhost:8081/artifactory/example-repo-local/helloworld.txt"
    }

  3. Fermez la session SSH en saisissant exit.

  4. Supprimez l'adresse IP externe, de sorte que l'Artifactory ne soit accessible qu'à partir de sources internes privées.

    gcloud compute instances delete-access-config --zone us-central1-a jfrog

Essayer d'accéder aux données de l'Artifactory

  1. Définissez les variables d'environnement pour stocker l'ID et le numéro de votre projet :

    PROJECT_ID=$(gcloud config list --format='value(core.project)')
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')

  2. Accordez le rôle Lecteur Compute Engine au compte de service Cloud Build pour pouvoir afficher l'adresse IP interne de votre instance JFrog :

    gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member=serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
    --role=roles/compute.viewer

  3. Créez un fichier nommé cloudbuild.yaml contenant le code suivant pour lire à partir de l'Artifactory. Il s'agit du fichier de configuration de compilation.

    La première étape récupère l'adresse IP interne de l'Artifactory que vous avez créé. La deuxième étape envoie une requête à cette adresse pour lire le fichier .txt que vous avez créé. Les étapes sont séparées afin de faciliter l'isolation des autorisations et des erreurs de mise en réseau. Si la première étape échoue, la cause est une erreur d'autorisation. Vous devez donc vous assurer que le compte de service Cloud Build a accès aux ressources Compute Engine, comme indiqué ci-dessus. Si la deuxième étape échoue, cela est dû à une erreur de mise en réseau. Le reste de ce tutoriel aborde les configurations réseau.

    steps:
  - id: Get Private Artifactory Address
    name: gcr.io/cloud-builders/gcloud
    entrypoint: /bin/bash
    args:
      - -c
      - |
        gcloud compute instances describe jfrog \
        --zone us-central1-a \
        --format="value(networkInterfaces.networkIP)" >> _INTERNAL_IP_ADDRESS

  - id: Pull from Private Artifactory
    name: gcr.io/cloud-builders/curl
    entrypoint: /bin/bash
    args:
      - -c
      - |
        curl -u admin:password --connect-timeout 10.00 \
        http://$(cat _INTERNAL_IP_ADDRESS):8081/artifactory/example-repo-local/helloworld.txt

  4. Lancez la compilation à l'aide du fichier de configuration de compilation.

    Par défaut, lorsque vous exécutez une compilation sur Cloud Build, celle-ci s'exécute dans un environnement sécurisé et hébergé avec accès à l'Internet public. Chaque compilation s'exécute sur son propre nœud de calcul et est isolée des autres charges de travail. Le pool par défaut présente des limitations sur la personnalisation de l'environnement, en particulier autour de l'accès au réseau privé. Dans cet exemple, vous essayez d'accéder à un réseau privé à partir d'un nœud de calcul public.

    Exécutez le fichier cloudbuild.yaml à l'aide de la commande suivante. Cela devrait échouer.

    gcloud builds submit --no-source

    La sortie sera semblable à ce qui suit :

    BUILD
Starting Step #0 - "Get Private Artifactory Address"
Step #0 - "Get Private Artifactory Address": Already have image (with digest): gcr.io/cloud-builders/gcloud
Finished Step #0 - "Get Private Artifactory Address"
Starting Step #1 - "Pull from Private Artifactory"
Step #1 - "Pull from Private Artifactory": Already have image (with digest): gcr.io/cloud-builders/curl
Step #1 - "Pull from Private Artifactory":   % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
Step #1 - "Pull from Private Artifactory":                                  Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:--  0:02:09 --:--:--     0curl: (7) Failed to connect to 10.128.0.2 port 8081: Connection timed out
Finished Step #1 - "Pull from Private Artifactory"
ERROR
ERROR: build step 1 "gcr.io/cloud-builders/curl" failed: step exited with non-zero status: 7

    L'expiration du délai de la connexion vous indique que Cloud Build ne parvient pas à atteindre l'adresse IP interne. Pour accéder à cette ressource privée, vous devez utiliser des pools privés Cloud Build.

Créer une connexion privée entre le réseau VPC de l'Artifactory et le réseau du producteur de services

  1. Tout d'abord, assurez-vous que votre réseau VPC autorise le trafic en entrée. Créez une règle de pare-feu pour autoriser le trafic interne entrant vers le réseau à destination de l'instance jfrog. La plage 10.0.0.0/16 se trouve dans un espace d'adressage privé, que vous utiliserez pour les pools privés Cloud Build dans les étapes ci-dessous.

    gcloud compute firewall-rules create allow-private-pools --direction=INGRESS \
--priority=1000 --network=default --action=ALLOW --rules=all --source-ranges=10.0.0.0/16

  2. Créez une plage réservée à utiliser par le pool privé Cloud Build pour les nœuds de calcul. La plage réservée doit se trouver dans le réseau où se trouve votre Artifactory. Dans ce cas, il s'agit du réseau de calcul default.

    Vous disposez de deux options lorsque vous définissez vos plages réservées. Vous pouvez spécifier explicitement la plage en fournissant les éléments --addresses et --prefix-length, ou autoriser Google Cloud à provisionner une plage disponible en fonction d'une valeur fournie pour prefix-length.

    Dans l'exemple ci-dessous, vous définissez explicitement les adresses pour qu'elles correspondent à la règle de pare-feu que vous avez créée. Le pool privé utilisera cet espace d'adressage et le trafic entrant ne sera pas bloqué.

    gcloud compute addresses create jfrog-ranges --global --purpose=VPC_PEERING \
--addresses=10.0.0.0 --prefix-length=16 --network=default

  3. Appairez le réseau VPC avec l'API Service Networking.

    Les pools privés Cloud Build exécutent des nœuds de calcul à l'aide de l'API Service Networking. Cela vous permet de proposer vos services gérés sur des adresses IP internes. Pour ce faire, effectuez un appairage du VPC géré par Google et exécutant les nœuds de calcul du pool privé Cloud Build avec votre propre VPC. Cette opération peut prendre quelques minutes.

    gcloud services vpc-peerings connect --service=servicenetworking.googleapis.com \
--ranges=jfrog-ranges --network=default

Créer le pool privé

  1. Le réseau VPC default est maintenant prêt à être utilisé avec les pools privés Cloud Build. Créez le pool privé et appairez-le avec le réseau VPC.

     gcloud builds worker-pools create jfrog-pool --region us-central1 \
 --peered-network=projects/${PROJECT_ID}/global/networks/default

  2. Pour exécuter votre compilation avec le nouveau pool privé, vous pouvez transmettre l'option --worker-pool avec la commande gcloud ou mettre à jour votre configuration cloudbuild.yaml pour vous assurer qu'elle utilise toujours le pool privé. Pour ce tutoriel, mettez à jour le fichier cloudbuild.yaml en ajoutant l'option suivante :

    options:
  pool:
    name: 'projects/${PROJECT_ID}/locations/us-central1/workerPools/jfrog-pool'

  3. Le fichier complet se présente comme suit :

    steps:
  - id: Get Private Artifactory Address
    name: gcr.io/cloud-builders/gcloud
    entrypoint: /bin/bash
    args:
      - -c
      - |
        gcloud compute instances describe jfrog \
        --zone us-central1-a \
        --format="value(networkInterfaces.networkIP)" >> _INTERNAL_IP_ADDRESS

  - id: Pull from Private Artifactory
    name: gcr.io/cloud-builders/curl
    entrypoint: /bin/bash
    args:
      - -c
      - |
        curl -u admin:password --connect-timeout 10.00 \
        http://$(cat _INTERNAL_IP_ADDRESS):8081/artifactory/example-repo-local/helloworld.txt

options:
  pool:
    name: 'projects/${PROJECT_ID}/locations/us-central1/workerPools/jfrog-pool'

  4. Démarrez la compilation :

     gcloud builds submit --no-source

  5. La compilation utilise le nouveau pool privé, appairé au réseau VPC, ce qui lui permet d'accéder à l'adresse IP interne de l'Artifactory. La sortie aboutit et Step #1 affiche "Hello world".

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Si vous avez créé un projet pour ce tutoriel, supprimez-le. Si vous avez utilisé un projet existant et que vous souhaitez le conserver sans les modifications du présent tutoriel, supprimez les ressources créées pour ce tutoriel.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

  1. Dans la console Google Cloud, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer les ressources du tutoriel

  1. Supprimez le service Compute Engine que vous avez déployé dans ce tutoriel :

     gcloud compute instances delete jfrog

  2. Supprimez la règle de pare-feu :

     gcloud compute firewall-rules delete allow-private-pools --network=default

  3. Supprimez la plage réservée :

     gcloud compute addresses delete jfrog-ranges --global

  4. Supprimez le pool privé Cloud Build :

     gcloud builds worker-pools delete jfrog-pool

Étapes suivantes