Esta página foi traduzida pela API Cloud Translation.

Acessar recursos em um JFrog Artifactory particular 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.

Crie o Artifactory particular

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

acessar a instância por SSH. A inicialização do contêiner pode levar alguns minutos.
```
gcloud compute ssh --zone us-central1-a jfrog
```
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
```

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

Crie um arquivo .txt para fazer o upload no Artifactory:
```
echo "Hello world" >> helloworld.txt
```

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"
    }

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

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)')

Conceda o papel Visualizador do Compute Engine à conta de serviço que você está usando para o build poder ver 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
```
Em que SERVICE_ACCOUNT é o e-mail da conta de serviço.
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 de 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
```

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

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
```
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 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
```
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

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

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'
```

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'

Inicie o build:
```
 gcloud builds submit --no-source
```
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".

Acessar recursos em um JFrog Artifactory particular com pools particulares Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.