Esta página foi traduzida pela API Cloud Translation.

Aceda a recursos num JFrog Artifactory privado com pools privados

Esta página demonstra como usar pools privados do Cloud Build para aceder a recursos de uma rede de nuvem virtual privada.

Neste tutorial, vai criar um JFrog Artifactory no Compute Engine alojado numa rede VPC privada e, em seguida, configurar uma compilação executada num conjunto privado para aceder aos dados desse Artifactory. O Jfrog Artifactory é um gestor de repositórios binários de código aberto.

Crie o Artifactory privado

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

SSH para a instância. O contentor pode demorar alguns minutos a ser inicializado.
```
gcloud compute ssh --zone us-central1-a jfrog
```
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
```

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

Crie um ficheiro TXT para carregar para o Artifactory:
```
echo "Hello world" >> helloworld.txt
```

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

Deve ser devolvido o seguinte:

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

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

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

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

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

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

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'

Inicie a compilação:
```
 gcloud builds submit --no-source
```
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".