Accedere alle risorse in un repository JFrog Artifactory privato con i pool privati

Questa pagina mostra come utilizzare i pool privati di Cloud Build per accedere alle risorse da una rete Virtual Private Cloud privata.

In questo tutorial creerai un JFrog Artifactory in Compute Engine ospitato in una rete VPC privata e poi configurerai una build in esecuzione in un pool privato per accedere ai dati di Artifactory. Jfrog Artifactory è un gestore di repository binari open source.

Crea l'istanza privata di Artifactory

1. Crea un'istanza Compute Engine da un container:

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

2. Accedi all'istanza tramite SSH. L'inizializzazione del contenitore potrebbe richiedere un paio di minuti.

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

3. Testa la connessione eseguendo questo comando. Una volta pronto, il contenitore risponderà con un codice HTTP 200, seguito da una pagina HTML.

   curl -i http://localhost:8081
   

4. Per creare un repository in Artifactory, devi firmare il contratto di licenza con l'utente finale (EULA) di JFrog:

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

   Vedrai un output simile al seguente:

       *   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
   

Caricare un file in Artifactory

1. Crea un file txt da caricare su Artifactory:

   echo "Hello world" >> helloworld.txt
   

2. JFrog include un repository di esempio predefinito. Carica nel repository utilizzando le credenziali predefinite:

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

   La query dovrebbe restituire:

       {
       "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. Termina la sessione SSH digitando exit.

4. Rimuovi l'indirizzo IP esterno, in modo che Artifactory sia accessibile solo da origini interne private.

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

Prova ad accedere ai dati da Artifactory

1. Imposta le variabili di ambiente per memorizzare l'ID e il numero del progetto:

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

2. Concedi il ruolo Visualizzatore Compute Engine al account di servizio che utilizzi per la build per poter visualizzare l'indirizzo IP interno della tua istanza JFrog:

   gcloud projects add-iam-policy-binding $PROJECT_ID \
       --member=serviceAccount:SERVICE_ACCOUNT \
       --role=roles/compute.viewer
   

   dove SERVICE_ACCOUNT è l'email del account di servizio.

3. Crea un file denominato cloudbuild.yaml contenente il seguente codice per leggere da Artifactory. Questo è il file di configurazione di compilazione.

   Il primo passaggio recupera l'indirizzo IP interno da Artifactory che hai creato. Il secondo passaggio invia una richiesta a questo indirizzo per leggere il file helloworld.txt che hai creato. I passaggi sono separati per semplificare l'isolamento degli errori di autorizzazione e di rete. Se il primo passaggio non va a buon fine, è dovuto a un errore di autorizzazione e devi assicurarti che l'account di servizio di build abbia accesso alle risorse di Compute Engine, come mostrato nel passaggio precedente. Se il secondo passaggio non va a buon fine, il problema è dovuto a un errore di rete. Il resto di questo tutorial riguarda le configurazioni di rete.

   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. Avvia una build utilizzando il file di configurazione della build.

   Per impostazione predefinita, quando esegui una build su Cloud Build, la build viene eseguita in un ambiente sicuro ospitato con accesso alla rete internet pubblica. Ogni build viene eseguita sul proprio worker ed è isolata dagli altri carichi di lavoro. Il pool predefinito ha limiti alla personalizzazione dell'ambiente, in particolare per quanto riguarda l'accesso alla rete privata. In questo esempio, stai tentando di accedere a una rete privata da un worker pubblico.

   Esegui cloudbuild.yaml con questo comando. Dovrebbe non riuscire.

   gcloud builds submit --no-source
   

   L'output sarà simile a questo:

   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
   

   Dal timeout della connessione puoi notare che Cloud Build non è in grado di raggiungere l'indirizzo IP interno. Per accedere a questa risorsa privata, devi utilizzare i pool privati di Cloud Build.

Crea una connessione privata tra la rete VPC di Artifactory e la rete del producer di servizi

1. Innanzitutto, assicurati che la tua rete VPC consenta l'ingresso. Crea una regola firewall per consentire il traffico interno in entrata alla rete con l'istanza jfrog. L'intervallo 10.0.0.0/16 si trova in uno spazio di indirizzi privati, che utilizzerai per i pool privati di Cloud Build nei passaggi seguenti.

   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. Crea un intervallo riservato per il pool privato Cloud Build da utilizzare per i worker. L'intervallo riservato deve trovarsi nella rete in cui si trova Artifactory. In questo caso, è la rete di computing default.

   Quando imposti gli intervalli riservati, hai due opzioni. Puoi specificare l'intervallo in modo esplicito fornendo --addresses e --prefix-length oppure puoi consentire a Google Cloud di eseguire il provisioning di un intervallo disponibile in base a un prefix-length fornito.

   Nell'esempio riportato di seguito, imposti esplicitamente gli indirizzi in modo che corrispondano alla regola firewall che hai creato. Il pool privato utilizzerà questo spazio di indirizzi e il traffico in entrata non verrà bloccato.

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

3. Esegui il peering della rete VPC con l'API Service Networking.

   I pool privati di Cloud Build eseguono i worker utilizzando l'API Service Networking. In questo modo puoi offrire i tuoi servizi gestiti su indirizzi IP interni. Ciò si ottiene eseguendo il peering del VPC gestito da Google che esegue i worker del pool privato Cloud Build con il tuo VPC. Il completamento dell'operazione potrebbe richiedere alcuni minuti.

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

Crea il pool privato

1. La rete VPC default è ora pronta per l'uso con i pool privati Cloud Build. Crea il pool privato ed esegui il peering con la rete VPC.

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

2. Per eseguire la build con il nuovo pool privato, puoi passare il flag --worker-pool con il comando gcloud o aggiornare la configurazione cloudbuild.yaml per assicurarti che utilizzi sempre il pool privato. Per questo tutorial, aggiorna cloudbuild.yaml aggiungendo l'opzione seguente:

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

3. Il file completo sarà simile al seguente:

   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. Avvia la build:

    gcloud builds submit --no-source
   

5. La build utilizzerà il nuovo pool privato, sottoposto a peering con la rete VPC, consentendogli di accedere all'indirizzo IP interno di Artifactory. L'output avrà esito positivo e Step #1 dovrebbe stampare "Hello world".