Diese Dokumentation bezieht sich auf die aktuelle Version von GKE on AWS, die im November 2021 veröffentlicht wurde. Weitere Informationen finden Sie in den Versionshinweisen.

Private Image-Registry verwenden

Ihre GKE on AWS-Installation kann standardmäßig auf öffentliche Container-Images zugreifen. In diesem Thema wird erläutert, wie Sie GKE on AWS mit einem privaten Container-Image-Repository wie Artifact Registry verwenden.

Ab Version 1.28 bietet GKE on AWS die Möglichkeit, private Images aus Artifact Registry oder Container Registry abzurufen, ohne ein Kubernetes Secret verwenden zu müssen. Weitere Informationen finden Sie unter Private Image-Registry ohne Secrets verwenden.

Hinweise

Führen Sie zuerst die folgende Aufgaben aus, um die Schritte auf dieser Seite auszuführen:

Cluster erstellen
Erstellen Sie einen Knotenpool.
Clusterzugriff für "kubectl" konfigurieren.
Docker-Image erstellen und in die Artifact Registry verschieben In den Beispielen auf dieser Seite wird der Container hello-app verwendet. Um diesen Container zu erstellen, folgen Sie den Schritten zu Container-Images erstellen und Docker-Image per Push an Artifact Registry übertragen, die Teil der GKE on Google Cloud Dokumentation sind.

In Artifact Registry nach Images suchen

Für die restlichen Schritte benötigen Sie ein Container-Image. Rufen Sie also den Namen Ihres Container-Images ab. Gehen Sie dazu so vor:

Konfigurieren Sie das Docker-Befehlszeilentool zur Authentifizierung bei Artifact Registry mit dem Google Cloud SDK:
```
gcloud auth configure-docker
```
Das gcloud-Befehlszeilentool registriert einen Credential Helper für alle von Google unterstützten Docker-Registrys.
Prüfen Sie, ob Ihre Artifact Registry ein Image mit dem Befehl docker images enthält.
```
docker images
```
Docker stellt eine Verbindung zu Artifact Registry her und gibt die in Ihrem Repository verfügbaren Images zurück. Die folgende Antwort zeigt beispielsweise ein Container-Image mit dem Namen hello-app im Repository PROJECT_NAME auf us-west1-docker.pkg.dev.
```
REPOSITORY                                                            TAG          IMAGE ID       CREATED          SIZE
us-west1-docker.pkg.dev/PROJECT_NAME/hello-repo/hello-app   v1           f7cfe0d58569   21 minutes ago   11.5MB
```

Wenn Sie noch kein Container-Image haben, erstellen Sie eines anhand der Schritte unter Container-Webanwendung bereitstellen.

Dienstkonto erstellen

Ihre Cluster authentifizieren sich über ein Dienstkonto für Identity and Access Management (IAM).

Um ein neues Dienstkonto zu erstellen, gehen Sie so vor:

Erstellen Sie ein IAM-Dienstkonto mit dem Google Cloud CLI.
```
gcloud iam service-accounts create ACCOUNT_NAME
```
Ersetzen Sie ACCOUNT_NAME durch den Namen des neuen Google Cloud-Dienstkontos.
Gewähren Sie dem Dienstkonto Artifact Registry-Berechtigungen.
```
gcloud projects add-iam-policy-binding PROJECT_NAME \
  --member serviceAccount:ACCOUNT_NAME@PROJECT_NAME.iam.gserviceaccount.com \
  --role roles/artifactregistry.reader
```
Ersetzen Sie Folgendes:
- PROJECT_NAME ist Ihr Google Cloud-Projekt.
- ACCOUNT_NAME ist der Name Ihres Google Cloud-Dienstkontos.
Laden Sie den Dienstkontoschlüssel des Kontos herunter.
```
gcloud iam service-accounts keys create registry-access-key.json \
  --iam-account ACCOUNT_NAME@PROJECT_NAME.iam.gserviceaccount.com
```
Ersetzen Sie Folgendes:
- PROJECT_NAME
- ACCOUNT_NAME
Hinweis: Mit dem Dienstkontoschlüssel können Sie auf privilegierte Ressourcen zugreifen. Schützen Sie die Schlüsseldatei nach dem Download.

Sie können Ihren Nutzercluster jetzt so konfigurieren, dass er eine Verbindung zu Artifact Registry herstellt.

Schlüssel im Cluster speichern

Damit der Schlüssel für die Authentifizierung bei Artifact Registry bereitgestellt wird, speichern Sie mit folgenden Schritten den Dienstkontoschlüssel als Kubernetes-Secret:

Verwenden Sie kubectl, um das Secret zu erstellen.

  kubectl create secret docker-registry registry-secret \
  --docker-server=LOCATION-docker.pkg.dev \
  --docker-username=_json_key \
  --docker-email=ACCOUNT_NAME@PROJECT_NAME.iam.gserviceaccount.com \
  --docker-password="$(cat registry-access-key.json)"

Ersetzen Sie Folgendes:

LOCATION: der regionale oder multiregionale Speicherort für das Repository.
PROJECT_NAME
ACCOUNT_NAME

Löschen Sie die lokale Kopie des Dienstkontoschlüssels.
```
rm registry-access-key.json
```

Sie können jetzt in Ihren Arbeitslasten auf dieses Secret verweisen.

Arbeitslast mit einem privaten Image erstellen

Wenn Sie ein Image aus einem privaten Container-Repository mit einer Arbeitslast verwenden möchten, setzen Sie das Feld spec.imagePullSecrets auf Ihren Secret-Namen. Dieses Feld befindet sich an unterschiedlichen Standorten für Pods und Deployments.

Pod erstellen

Zum Erstellen eines Pods, der auf die Container Registry zugreifen kann, legen Sie das Feld spec.imagePullSecrets auf den Namen Ihres Secrets fest.

Erstellen Sie einen Pod, der spec.imagePullSecrets angibt.

apiVersion: v1
kind: Pod
metadata:
  name: POD_NAME
spec:
  containers:
  - name: CONTAINER_NAME
    image: LOCATION-docker.pkg.dev/PROJECT_NAME/hello-repo/hello-app:v1
  imagePullSecrets:
  - name: registry-secret

Ersetzen Sie Folgendes:

POD_NAME: der Name Ihres Pods
CONTAINER_NAME: der Name des Containers im Pod
LOCATION
PROJECT_NAME

Wenn Sie zum Beispiel das Image hello-app abrufen möchten, kopieren Sie die folgende YAML-Datei in eine Datei mit dem Namen hello-pod.yaml.

apiVersion: v1
kind: Pod
metadata:
  name: hello-pod
spec:
  containers:
  - name: hello-container
    image: us-west1-docker.pkg.dev/example-project/hello-repo/hello-app:v1
  imagePullSecrets:
  - name: registry-secret

Wenden Sie die Konfiguration mithilfe von kubectl auf Ihren Cluster an.
```
kubectl apply -f hello-pod.yaml
```
Bestätigen Sie mithilfe von kubectl get, dass der Pod ausgeführt wird.
```
kubectl get pod/hello-pod
```
Die Antwort enthält einen Pod mit dem Status Running.
```
NAME        READY   STATUS    RESTARTS   AGE
hello-pod   1/1     Running   0          15s
```

Deployment erstellen

Zur Verwendung eines privaten Repositorys in einem Deployment geben Sie das imagePullSecret in der Vorlage an.

Wenn Sie beispielsweise eine Bereitstellung konfigurieren möchten, das das Image hello-app verwendet, erstellen Sie eine Datei namens hello-deployment.yaml mit folgendem Inhalt:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-app-deployment
spec:
  selector:
    matchLabels:
      app: products
      department: sales
  replicas: 3
  template:
    metadata:
      labels:
        app: products
        department: sales
    spec:
      containers:
      - name: hello
        image: LOCATION-docker.pkg.dev/PROJECT_NAME/hello-repo/hello-app:v1
        env:
        - name: "PORT"
          value: "50001"
      imagePullSecrets:
      - name: registry-secret

Ersetzen Sie Folgendes:

LOCATION
PROJECT_NAME

Wenden Sie die Konfiguration mithilfe von kubectl auf Ihren Cluster an.
```
kubectl apply -f hello-deployment.yaml
```

Bestätigen Sie mithilfe von kubectl pods, dass Ihre Bereitstellung ausgeführt wird.

kubectl get pods --selector=app=products

Die Ausgabe zeigt drei Running-Pods.

NAME                                    READY   STATUS    RESTARTS   AGE
hello-app-deployment-67d9c6d98c-b69f2   1/1     Running   0          14m
hello-app-deployment-67d9c6d98c-d6k5c   1/1     Running   0          14m
hello-app-deployment-67d9c6d98c-p2md5   1/1     Running   0          14m

Bereinigen

Führen Sie die folgenden Befehle aus, um die auf dieser Seite erstellten Ressourcen zu entfernen:

kubectl apply -f hello-pod.yaml
kubectl delete -f hello-deployment.yaml

Nächste Schritte

Artifact Registry – Übersicht