Accede a recursos en un JFrog Artifactory privado con grupos privados

En esta página, se muestra cómo usar grupos privados de Cloud Build para acceder a los recursos desde una red de nube privada virtual privada.

En este instructivo, crearás un JFrog Artifactory en Compute Engine alojado en una red de VPC privada y, luego, configurarás una compilación que se ejecute en un grupo privado para acceder a los datos de ese Artifactory. JFrog Artifactory es un administrador de repositorios binarios de código abierto.

Crea el Artifactory privado

  1. Crear una instancia de Compute Engine desde un contenedor:

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

  2. Establecer una conexión SSH a la instancia La inicialización del contenedor puede tardar unos minutos.

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

  3. Ejecuta el siguiente comando para probar la conexión: Una vez que el contenedor esté listo, responderá con un código HTTP 200, seguido de una página HTML.

    curl -i http://localhost:8081

  4. Para crear un repositorio en Artifactory, debes firmar el CLUF (Contrato de licencia para el usuario final) de JFrog:

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

    Verás un resultado similar al siguiente:

        *   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

Subir un archivo a Artifactory

  1. Crea un archivo txt para subir a Artifactory:

    echo "Hello world" >> helloworld.txt

  2. JFrog viene con un repositorio de ejemplo predeterminado. Sube al repositorio con las credenciales predeterminadas:

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

    Se debería mostrar lo siguiente:

        {
    "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. Para finalizar la sesión SSH, escribe exit.

  4. Quita la dirección IP externa, por lo que solo se podrá acceder a Artifactory desde fuentes internas privadas.

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

Intenta acceder a los datos de Artifactory

  1. Configura las variables de entorno para almacenar el ID y el número del proyecto:

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

  2. Otorga el rol Visualizador de Compute Engine a la cuenta de servicio que usas para la compilación y, así, poder ver la dirección IP interna de tu instancia de JFrog:

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

    Aquí, SERVICE_ACCOUNT es el correo electrónico de la cuenta de servicio.

  3. Crea un archivo llamado cloudbuild.yaml que contenga el siguiente código para leer desde Artifactory. Este es el archivo de configuración de compilación.

    En el primer paso, se recupera la dirección IP interna de Artifactory que creaste. El segundo paso envía una solicitud a esa dirección para leer el archivo helloworld.txt que creaste. Los pasos están separados para facilitar el aislamiento de permisos y errores de red. Si el primer paso falla, se debe a un error de permisos y deberás asegurarte de que la cuenta de servicio de compilación tenga acceso a los recursos de Compute Engine, como se muestra en el paso anterior. Si el segundo paso falla, se debe a un error de red. En el resto de este instructivo, se abordan las opciones de configuración de red.

    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. Usa un comando para comenzar a compilar mediante el archivo de configuración de compilación:

    De forma predeterminada, cuando ejecutas una compilación en Cloud Build, la compilación se ejecuta en un entorno alojado y seguro con acceso a la Internet pública. Cada compilación se ejecuta en su propio trabajador y está aislada de otras cargas de trabajo. El grupo predeterminado tiene límites sobre cuánto puedes personalizar el entorno, especialmente en cuanto al acceso a la red privada. En este ejemplo, intentas acceder a una red privada desde un trabajador público.

    Ejecuta cloudbuild.yaml con el siguiente comando. Debe fallar.

    gcloud builds submit --no-source

    El resultado se verá similar a lo siguiente:

    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

    Puedes ver por el tiempo de espera de conexión que Cloud Build no puede acceder a la dirección IP interna. Para acceder a este recurso privado, debes usar grupos privados de Cloud Build.

Crea una conexión privada entre la red de VPC de Artifactory y la red del productor de servicios

  1. Primero, asegúrate de que tu red de VPC permita la entrada. Crea una regla de firewall para permitir el tráfico interno entrante a la red con la instancia jfrog. El rango 10.0.0.0/16 se encuentra en un espacio de direcciones privadas, que usarás para los grupos privados de Cloud Build en los pasos a continuación.

    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 rango reservado para el grupo privado de Cloud Build a fin de usarlo con los trabajadores. El rango reservado debe estar en la red en la que se encuentra tu Artifactory. En este caso, es la red de procesamiento de default.

    Cuando configuras tus rangos reservados, tienes dos opciones. Puedes especificar el rango de forma explícita si proporcionas --addresses y --prefix-length, o puedes permitir que Google Cloud aprovisione un rango disponible en función de un prefix-length proporcionado.

    En el siguiente ejemplo, se configuran explícitamente las direcciones para que coincidan con la regla de firewall que creaste. El grupo privado usará este espacio de direcciones y el tráfico entrante no se bloqueará.

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

  3. Realiza un intercambio de tráfico entre la red de VPC y la API de Herramientas de redes de servicios.

    Los grupos privados de Cloud Build ejecutan trabajadores con la API de Service Networking. Esto te permite ofrecer tus servicios administrados en direcciones IP internas. Esto se logra intercambiando tráfico entre la VPC administrada por Google que ejecuta los trabajadores del grupo privado de Cloud Build y tu propia VPC. Puede tardar unos minutos en completarse.

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

Crea el grupo privado

  1. La red de VPC default ahora está lista para usarse con grupos privados de Cloud Build. Crea el grupo privado y usa el intercambio de tráfico con la red de VPC.

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

  2. Para ejecutar tu compilación con el nuevo grupo privado, puedes pasar la marca --worker-pool con el comando gcloud o actualizar tu configuración de cloudbuild.yaml a fin de asegurarte de que siempre use el grupo privado. Para este instructivo, agrega la siguiente opción a fin de actualizar cloudbuild.yaml:

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

  3. El archivo completo se verá de la siguiente manera:

    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. Comienza la compilación:

     gcloud builds submit --no-source

  5. La compilación usará el nuevo grupo privado, que intercambia tráfico con la red de VPC, lo que le permitirá acceder a la dirección IP interna de Artifactory. El resultado será correcto y Step #1 debe imprimir “Hello world”.