Aceda a recursos num JFrog Artifactory privado com pools privados

Crie o Artifactory privado

1. Crie uma instância do Compute Engine a partir de um contentor:

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

2. SSH para a instância. O contentor pode demorar alguns minutos a ser inicializado.

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

3. Teste a ligação executando o seguinte comando. Assim que o contentor estiver pronto, responde com um código HTTP 200, seguido de uma página HTML.

   curl -i http://localhost:8081
   

4. Para criar um repositório no Artifactory, tem de assinar o EULA (contrato de licença de utilizador final) da JFrog:

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

   Vai ver um resultado semelhante ao seguinte:

       *   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
   

Carregue um ficheiro para o Artifactory

1. Crie um ficheiro TXT para carregar para o Artifactory:

   echo "Hello world" >> helloworld.txt
   

2. O JFrog inclui um repositório de exemplo predefinido. Carregue para o repositório através das credenciais predefinidas:

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

   Isto deve devolver:

       {
       "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. Termine a sessão SSH escrevendo exit.

4. Remova o endereço IP externo para que o Artifactory só fique acessível a partir de origens internas privadas.

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

Experimente aceder aos dados a partir do Artifactory

1. Defina variáveis de ambiente para armazenar o ID e o número do projeto:

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

2. Conceda a função Visualizador do Compute Engine à conta de serviço que está a usar para que a compilação possa ver o endereço IP interno da sua instância do JFrog:

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

   Em que SERVICE_ACCOUNT é o email da conta de serviço.

3. Crie um ficheiro denominado cloudbuild.yaml que contenha o seguinte código para ler a partir do Artifactory. Este é o ficheiro de configuração da compilação.

   O primeiro passo obtém o endereço IP interno do Artifactory que criou. O segundo passo envia um pedido para esse endereço para ler o ficheiro helloworld.txt que criou. Os passos estão separados para facilitar o isolamento de erros de autorizações e de rede. Se o primeiro passo falhar, deve-se a um erro de autorizações e tem de garantir que a conta de serviço de compilação tem acesso aos recursos do Compute Engine, conforme mostrado no passo anterior. Se o segundo passo falhar, deve-se a um erro de rede. O resto deste tutorial aborda as configurações de rede.

   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. Inicie uma compilação com o ficheiro de configuração de compilação.

   Por predefinição, quando executa uma compilação no Cloud Build, esta é executada num ambiente alojado seguro com acesso à Internet pública. Cada compilação é executada no seu próprio trabalhador e está isolada de outras cargas de trabalho. O conjunto predefinido tem limites quanto à personalização do ambiente, especialmente no que diz respeito ao acesso à rede privada. Neste exemplo, está a tentar aceder a uma rede privada a partir de um trabalhador público.

   Execute o cloudbuild.yaml com o seguinte comando. Deve falhar.

   gcloud builds submit --no-source
   

   O resultado vai ter um aspeto semelhante a:

   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
   

   Pode ver pelo limite de tempo da ligação que o Cloud Build não consegue alcançar o endereço IP interno. Para aceder a este recurso privado, tem de usar os conjuntos privados do Cloud Build.

Crie uma ligação privada entre a rede VPC do Artifactory e a rede do produtor de serviços

1. Primeiro, certifique-se de que a sua rede VPC permite a entrada. Crie uma regra de firewall para permitir o tráfego interno de entrada para a rede com a instância jfrog. O intervalo 10.0.0.0/16 está num espaço de endereços privado, que vai usar para os conjuntos privados do Cloud Build nos passos abaixo.

   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. Crie um intervalo reservado para o pool privado do Cloud Build usar para os trabalhadores. O intervalo reservado tem de estar na rede onde o Artifactory está localizado. Neste caso, é a defaultrede de computação.

   Tem duas opções quando define os intervalos reservados. Pode especificar o intervalo explicitamente indicando --addresses e --prefix-length ou permitir que Google Cloud aprovisione um intervalo disponível com base num prefix-length fornecido.

   No exemplo abaixo, define explicitamente os endereços para corresponderem à regra de firewall que criou. O conjunto privado vai usar este espaço de endereços e o tráfego de entrada não vai ser bloqueado.

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

3. Estabeleça o intercâmbio da rede da VPC com a API Service Networking.

   As pools privadas do Cloud Build executam trabalhadores através da API Service Networking. Isto permite-lhe oferecer os seus serviços geridos em endereços IP internos. Isto é conseguido através do intercâmbio da VPC gerida pela Google que executa os trabalhadores do pool privado do Cloud Build com a sua própria VPC. Este processo pode demorar alguns minutos.

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

Crie o grupo privado

1. A rede defaultVPC já está pronta para utilização com pools privadas do Cloud Build. Crie o conjunto privado e estabeleça uma relação de interligação com a rede VPC.

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

2. Para executar a compilação com o novo conjunto privado, pode transmitir a flag --worker-pool com o comando gcloud ou atualizar a configuração cloudbuild.yaml para garantir que usa sempre o conjunto privado. Para este tutorial, atualize o cloudbuild.yaml adicionando a seguinte opção:

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

3. O ficheiro completo tem o seguinte aspeto:

   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. Inicie a compilação:

    gcloud builds submit --no-source
   

5. A compilação vai usar o novo pool privado, com peering com a rede VPC, o que lhe permite aceder ao endereço IP interno do Artifactory. O resultado é bem-sucedido e Step #1 deve imprimir "Hello world".