Cette page a été traduite par l'API Cloud Translation.

Accéder aux ressources d'un dépôt 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.

Créer l'Artifactory privé

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

Vous connecter en SSH à l'instance L'initialisation du conteneur peut prendre quelques minutes.
```
gcloud compute ssh --zone us-central1-a jfrog
```
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
```

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

Créez un fichier .txt à importer dans l'Artifactory :
```
echo "Hello world" >> helloworld.txt
```

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"
    }

Fermez la session SSH en saisissant exit.
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

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)')

Accordez le rôle Lecteur Compute Engine au compte de service que vous utilisez pour la compilation afin de pouvoir afficher l'adresse IP interne de votre instance JFrog :
```
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member=serviceAccount:SERVICE_ACCOUNT \
    --role=roles/compute.viewer
```
où SERVICE_ACCOUNT correspond à l'adresse e-mail du compte de service.
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 helloworld.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 de compilation a accès aux ressources Compute Engine, comme indiqué à l'étape précédente. 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
```

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

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
```
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
```
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é

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
```
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'
```

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'

Démarrez la compilation :
```
 gcloud builds submit --no-source
```
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".