Acessar recursos em um JFrog Artifactory privado com pools privados

Nesta página, você aprende a usar os pools particulares do Cloud Build para acessar recursos de uma rede privada de nuvem privada virtual.

Neste tutorial, você criará um JFrog Artifactory no Compute Engine hospedado em uma rede VPC privada e definirá uma versão em execução em um pool privado para acessar dados desse artefato. O Jfrog Artifactory é um gerenciador de repositório binário de código aberto.

Objetivos

  • Configure um Jfrog Artifactory no Compute Engine
  • Faça o upload de um arquivo no Artifactory
  • Criar um pool privado
  • Faça o peering da rede produtora de serviços que hospeda o pool privado para a rede da nuvem privada virtual do Artifactory
  • Crie um arquivo de configuração do build para acessar os dados no Artifactory.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

  • Compute Engine
  • Cloud Build

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  4. Enable the Compute Engine, Cloud Build, Service Networking APIs.

    Enable the APIs

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  7. Enable the Compute Engine, Cloud Build, Service Networking APIs.

    Enable the APIs

    8.

Opção A: usar o Cloud Shell

Siga este tutorial usando o Cloud Shell, que vem pré-instalado com a CLI do Google Cloud usada neste tutorial. Se você usa o Cloud Shell, não precisa instalar essas ferramentas de linha de comando na sua estação de trabalho.

Para usar o Cloud Shell:

  1. Acesse o Console do Google Cloud.

    Console do Google Cloud

  2. Clique no botão Ativar Cloud Shell na parte superior da janela do Console do Google Cloud. Botão "Ativar shell"

    Uma sessão do Cloud Shell é aberta dentro de um novo frame na parte inferior do Console do Google Cloud, e exibe um prompt de linha de comando.

    Sessão do Cloud Shell

Opção B: usar ferramentas de linha de comando localmente

Se você preferir seguir este tutorial na sua estação de trabalho, siga estas etapas para instalar as ferramentas necessárias.

  1. Instale a CLI do Google Cloud.

Crie o Artifactory particular

  1. Crie uma instância do Compute Engine a partir de um contêiner:

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

  2. acessar a instância por SSH. A inicialização do contêiner pode levar alguns minutos.

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

  3. Execute o seguinte comando para testar a conexão. Quando o contêiner estiver pronto, ele responderá com um código HTTP 200, seguido por uma página HTML.

    curl -i http://localhost:8081

  4. Para criar um repositório no Artifactory, você precisa assinar o Contrato de licença de usuário final (EULA, na sigla em inglês) do JFrog:

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

    Você verá um resultado semelhante a este:

        *   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

Faça o upload de um arquivo no Artifactory

  1. Crie um arquivo .txt para fazer o upload no Artifactory:

    echo "Hello world" >> helloworld.txt

  2. O JFrog vem com um repositório de exemplo padrão. Faça upload para o repositório usando as credenciais padrão:

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

    Isso retornará:

        {
    "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 encerrar a sessão SSH, digite exit.

  4. Remova o endereço IP externo para que o Artifactory só possa ser acessado por origens internas particulares.

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

Tente acessar os dados no 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 o papel Visualizador do Compute Engine à conta de serviço que você está usando para que o build possa acessar o endereço IP interno da instância do JFrog:

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

    Onde SERVICE_ACCOUNT é o e-mail da conta de serviço.

  3. Crie um arquivo chamado cloudbuild.yaml contendo o seguinte código para ler o Artifactory. Este é o arquivo de configuração da compilação.

    A primeira etapa busca o endereço IP interno do Artifactory que você criou. A segunda etapa envia uma solicitação a esse endereço para ler o arquivo helloworld.txt que você criou. As etapas são separadas para facilitar o isolamento de permissões e os erros de rede. Se a primeira etapa falhar, o motivo é um erro de permissão, e você precisará garantir que a conta de serviço do build tenha acesso aos recursos do Compute Engine, conforme mostrado na etapa anterior. Se a segunda etapa falhar, isso é devido a um erro de rede. O restante 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 usando o arquivo de configuração da compilação.

    Por padrão, quando você executa um build no Cloud Build, ele é executado em um ambiente hospedado e seguro, com acesso à Internet pública. Cada build é executado no próprio worker e isolado de outras cargas de trabalho. O pool padrão tem limites de personalização do ambiente, especialmente em torno do acesso à rede privada. Neste exemplo, você está tentando acessar uma rede privada de um worker público.

    Execute o cloudbuild.yaml com o seguinte comando: Ocorrerá uma falha.

    gcloud builds submit --no-source

    A resposta será similar a esta:

    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

    Observe pelo tempo limite de conexão que o Cloud Build não consegue alcançar o endereço IP interno. Para acessar esse recurso particular, use os pools particulares do Cloud Build.

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

  1. Primeiro, verifique se a rede VPC permite a entrada. Crie uma regra de firewall para permitir tráfego interno de entrada para a rede com a instância jfrog. O intervalo 10.0.0.0/16 está em um espaço de endereço privado, que você usará para os pools privados do Cloud Build nas etapas 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 e utilize-o para os workers. O intervalo reservado precisa estar na rede em que o Artifactory está localizado. Neste caso, é a rede de computação default.

    Você tem duas opções ao definir os intervalos reservados. É possível especificar o intervalo explicitamente fornecendo --addresses e --prefix-length, ou permitir que o Google Cloud provisione um intervalo disponível com base em um prefix-length fornecido.

    No exemplo abaixo, você definiu explicitamente os endereços para corresponderem à regra de firewall criada. O pool particular usará esse espaço de endereço, e o tráfego de entrada não será bloqueado.

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

  3. Faça o peering da rede VPC com a API Service Networking.

    Os pools particulares do Cloud Build executam workers usando a API Service Networking. Isso permite que você ofereça seus serviços gerenciados em endereços IP internos. Para isso, use a própria VPC para fazer o peering da VPC gerenciada pelo Google que executa os workers do pool particular do Cloud Build. Isso pode levar alguns minutos para ser concluído.

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

Criar o pool particular

  1. A rede VPC default está pronta para ser usada com pools privados do Cloud Build. Crie o pool particular e faça o peering 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 seu build com o novo pool particular, é possível transmitir a sinalização --worker-pool com o comando gcloud ou atualizar sua configuração cloudbuild.yaml para garantir que ele sempre use o pool particular. Para este tutorial, atualize a cloudbuild.yaml adicionando a seguinte opção:

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

  3. O arquivo completo terá a seguinte aparência:

    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 o build:

     gcloud builds submit --no-source

  5. A versão usará o novo pool particular, com peering na rede VPC, permitindo que ele acesse o endereço IP interno do Artifactory. A saída será bem-sucedida e Step #1 exibirá "Hello world".

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Se você criou um novo projeto para este tutorial, exclua o projeto. Se você usou um projeto atual e quer mantê-lo sem as alterações incluídas neste tutorial, exclua os recursos criados para o tutorial.

Como excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Como excluir recursos do tutorial

  1. Exclua o serviço do Compute Engine implantado neste tutorial:

     gcloud compute instances delete jfrog

  2. Exclua a regra do firewall:

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

  3. Remova o intervalo reservado:

     gcloud compute addresses delete jfrog-ranges --global

  4. Exclua o pool particular do Cloud Build:

     gcloud builds worker-pools delete jfrog-pool

A seguir