Acessar recursos em um artefato JFrog privado com pools particulares

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. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

  2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

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

  4. Ative as APIs Compute Engine, Cloud Build, Service Networking.

    Ative as APIs

    5.

  5. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

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

  7. Ative as APIs Compute Engine, Cloud Build, Service Networking.

    Ative as APIs

    8.

Opção A: usar o Cloud Shell

Siga este tutorial usando o Cloud Shell, que vem pré-instalado com a Google Cloud CLI 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 do Cloud Build para poder ver o endereço IP interno da instância do JFrog:

    gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member=serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
    --role=roles/compute.viewer

  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 .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 Cloud Build tenha acesso aos recursos do Compute Engine, conforme mostrado acima. 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. No Console do Google Cloud, acesse a página Gerenciar recursos.

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

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