Diese Seite wurde von der Cloud Translation API übersetzt.

Auf Ressourcen in einem privaten JFrog Artifactory mit privaten Pools zugreifen

Auf dieser Seite wird gezeigt, wie Sie mit privaten Cloud Build-Pools auf Ressourcen von einem privaten Virtual Private Cloud-Netzwerk aus zugreifen.

In dieser Anleitung erstellen Sie ein JFrog Artifactory in Compute Engine, das in einem privaten VPC-Netzwerk gehostet wird, und konfigurieren dann einen Build, der in einem privaten Pool läuft, um auf Daten aus diesem Artifactory zuzugreifen. Jfog Artifactory ist ein Open-Source-Repository für binäre Repositories.

Privates Artifactory erstellen

Erstellen Sie eine Compute Engine-Instanz aus einem Container:

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

SSH-Verbindung mit der Instanz herstellen Es kann einige Minuten dauern, bis der Container initialisiert ist.
```
gcloud compute ssh --zone us-central1-a jfrog
```
Testen Sie die Verbindung mit dem folgenden Befehl. Sobald der Container bereit ist, antwortet er mit dem HTTP-Code 200, gefolgt von einer HTML-Seite.
```
curl -i http://localhost:8081
```

Damit Sie ein Repository im Artifactory erstellen können, müssen Sie die JFrog-EULA (Endnutzer-Lizenzvereinbarung) signieren:

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

Die Ausgabe sollte in etwa so aussehen:

    *   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

Datei in das Artifactory hochladen

Erstellen Sie eine TXT-Datei, die in das Artifactory hochgeladen werden soll:
```
echo "Hello world" >> helloworld.txt
```

JFrog umfasst ein Standard-Beispiel-Repository. Laden Sie es mit den Standardanmeldedaten in das Repository hoch:

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

In diesem Fall sollte Folgendes zurückgegeben werden:

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

Beenden Sie die SSH-Sitzung. Geben Sie dazu exit ein.
Entfernen Sie die externe IP-Adresse, sodass auf das Artefakt nur über private interne Quellen zugegriffen werden kann.
```
gcloud compute instances delete-access-config --zone us-central1-a jfrog
```

Auf die Daten aus dem Artifactory zugreifen

Legen Sie Umgebungsvariablen zum Speichern Ihrer Projekt-ID und Projektnummer fest:

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

Weisen Sie dem Dienstkonto, das Sie für den Build verwenden, die Rolle Compute Engine-Betrachter zu, damit die interne IP-Adresse der JFrog-Instanz aufgerufen werden kann:
```
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member=serviceAccount:SERVICE_ACCOUNT \
    --role=roles/compute.viewer
```
Dabei ist SERVICE_ACCOUNT die E-Mail-Adresse des Dienstkontos.
Erstellen Sie eine Datei mit dem Namen cloudbuild.yaml, die den folgenden Code enthält, der aus dem Artifactory gelesen wird. Dies ist die Build-Konfigurationsdatei.

Im ersten Schritt wird die interne IP-Adresse aus dem von Ihnen erstellten Artifactory abgerufen. Im zweiten Schritt wird eine Anfrage an diese Adresse gesendet, um die von Ihnen erstellte helloworld.txt-Datei zu lesen. Die Schritte sind getrennt, um Berechtigungen und Netzwerkfehler zu isolieren. Wenn der erste Schritt fehlschlägt, liegt dies an einem Berechtigungsfehler. Das Build-Dienstkonto muss Zugriff auf die Compute Engine-Ressourcen haben, wie im vorherigen Schritt gezeigt. Wenn der zweite Schritt fehlschlägt, liegt ein Netzwerkfehler vor. Im weiteren Verlauf dieser Anleitung werden die Netzwerkkonfigurationen behandelt.
```
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
```

Starten Sie mit der Build-Konfigurationsdatei einen Build:

Wenn Sie einen Build auf Cloud Build ausführen, wird er standardmäßig in einer sicheren, gehosteten Umgebung mit Zugriff auf das öffentliche Internet ausgeführt. Jeder Build wird auf einem eigenen Worker ausgeführt und von anderen Arbeitslasten isoliert. Der Standardpool bietet nur begrenzte Möglichkeiten zur Anpassung der Umgebung, insbesondere im Hinblick auf den privaten Netzwerkzugriff. In diesem Beispiel versuchen Sie, von einem öffentlichen Worker aus auf ein privates Netzwerk zuzugreifen.

Führen Sie die cloudbuild.yaml mit dem folgenden Befehl aus. Es sollte fehlschlagen.

gcloud builds submit --no-source

Die Ausgabe sieht etwa so aus:

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

Sie sehen am Zeitlimit der Verbindung, dass Cloud Build die interne IP-Adresse nicht erreichen kann. Für den Zugriff auf diese private Ressource müssen Sie private Cloud Build-Pools verwenden.

Private Verbindung zwischen dem VPC-Netzwerk von Artifactory und dem Diensterstellernetzwerk erstellen

Prüfen Sie zuerst, ob Ihr VPC-Netzwerk eingehenden Traffic zulässt. Erstellen Sie eine Firewallregel, um eingehenden internen Traffic zum Netzwerk mit der Instanz jfrog zuzulassen. Der Bereich 10.0.0.0/16 befindet sich in einem privaten Adressbereich, den Sie in den folgenden Schritten für private Cloud Build-Pools verwenden.
```
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
```
Erstellen Sie einen reservierten Bereich für den privaten Cloud Build-Pool, um ihn für die Worker zu verwenden. Der reservierte Bereich muss sich in dem Netzwerk befinden, in dem sich Ihr Artefakt befindet. In diesem Fall ist es das Compute-Netzwerk default.

Beim Festlegen Ihrer reservierten Bereiche haben Sie zwei Möglichkeiten. Sie können den Bereich entweder explizit angeben. Geben Sie dazu --addresses und --prefix-length an. Oder erlauben Sie Google Cloud , einen verfügbaren Bereich basierend auf einem bereitgestellten prefix-length bereitzustellen.

Im folgenden Beispiel legen Sie die Adressen explizit so fest, dass sie der von Ihnen erstellten Firewallregel entsprechen. Der private Pool verwendet diesen Adressbereich und der eingehende Traffic wird nicht blockiert.
```
gcloud compute addresses create jfrog-ranges --global --purpose=VPC_PEERING \
--addresses=10.0.0.0 --prefix-length=16 --network=default
```
Verbinden Sie durch Peering das VPC-Netzwerk mit der Service Networking API.

Private Cloud Build-Pools führen Worker mithilfe der Service Networking API aus. Dadurch können Sie Ihre verwalteten Dienste über interne IP-Adressen anbieten. Dies wird durch Peering der von Google verwalteten VPC erreicht, auf der die privaten Cloud Build-Pool-Worker mit Ihrer eigenen VPC ausgeführt werden. Dies kann einige Minuten dauern.
```
gcloud services vpc-peerings connect --service=servicenetworking.googleapis.com \
--ranges=jfrog-ranges --network=default
```

Privaten Pool erstellen

Das VPC-Netzwerk default kann jetzt mit privaten Cloud Build-Pools verwendet werden. Erstellen Sie den privaten Pool und verbinden Sie ihn mit dem VPC-Netzwerk.
```
 gcloud builds worker-pools create jfrog-pool --region us-central1 \
 --peered-network=projects/${PROJECT_ID}/global/networks/default
```
Um Ihren Build mit dem neuen privaten Pool auszuführen, können Sie entweder das Flag --worker-pool mit dem gcloud-Befehl übergeben oder Ihre cloudbuild.yaml-Konfiguration aktualisieren, damit sie immer den privaten Pool verwendet. Aktualisieren Sie für diese Anleitung cloudbuild.yaml. Fügen Sie dazu die folgende Option hinzu:
```
options:
  pool:
    name: 'projects/${PROJECT_ID}/locations/us-central1/workerPools/jfrog-pool'
```

Die vollständige Datei sieht so aus:

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'

Build starten:
```
 gcloud builds submit --no-source
```
Der Build verwendet den neuen privaten Pool, der mit dem VPC-Netzwerk verbunden ist, sodass er auf die interne IP-Adresse des Artifactory zugreifen kann. Die Ausgabe ist erfolgreich und Step #1 sollte "Hello world" ausgeben.

Auf Ressourcen in einem privaten JFrog Artifactory mit privaten Pools zugreifen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.