Diese Seite wurde von der Cloud Translation API übersetzt.

Container-Webserveranwendung bereitstellen

In dieser Anleitung wird beschrieben, wie Sie eine Containeranwendung in einer GDC-Umgebung (Google Distributed Cloud) ohne Internetverbindung hochladen und in der Appliance-Umgebung ausführen. In diesem Tutorial erfahren Sie, wie Sie Harbor-Projekte erstellen, Bilder in Harbor hochladen und Arbeitslasten erstellen. Eine containerisierte Arbeitslast wird in einem Projekt-Namespace ausgeführt.

Die GDC-Appliance-Umgebung mit Air Gap enthält eine vorkonfigurierte Harbor-Registry namens tear-harbor in einem GDC-Projekt namens tear. Sie verwenden diese Registry in diesem Beispiel.

In dieser Anleitung wird eine Beispiel-Webserver-App verwendet, die in der Google CloudArtifact Registry verfügbar ist.

Ziele

Container-Image per Push in die verwaltete Harbor-Registry übertragen
Beispiel-Containeranwendung im Cluster bereitstellen

Hinweise

Sie benötigen ein Projekt, um Ihre containerisierten Bereitstellungen zu verwalten. Erstellen Sie ein Projekt, falls Sie noch keines haben.
Legen Sie den Namespace Ihres Projekts als Umgebungsvariable fest:
```
export NAMESPACE=PROJECT_NAMESPACE
```
Laden Sie die gcloud CLI herunter und installieren Sie sie.
Bitten Sie Ihren IAM-Administrator der Organisation, Ihnen die folgenden Rollen zuzuweisen:
- Rolle „Namespace-Administrator“ (namespace-admin) für Ihren Projekt-Namespace. Diese Rolle ist erforderlich, um Containerarbeitslasten in Ihrem Projekt bereitzustellen.
- Rolle „Harbor Instance Viewer“ (harbor-instance-viewer) für den Namespace Ihres Projekts. Diese Rolle ist erforderlich, um eine Harbor-Instanz aufzurufen und auszuwählen.
- Rolle „Harbor Project Creator“ (harbor-project-creator) für Ihren Projektnamespace. Diese Rolle ist für den Zugriff auf und die Verwaltung eines Harbor-Projekts erforderlich.
Melden Sie sich im Kubernetes-Cluster an und generieren Sie die kubeconfig-Datei mit einer Nutzeridentität. Achten Sie darauf, dass Sie den kubeconfig-Pfad als Umgebungsvariable festlegen:
```
export KUBECONFIG=CLUSTER_KUBECONFIG
```

Harbor-Projekt in der Registry erstellen

GDC bietet Harbor as a Service an, einen vollständig verwalteten Dienst, mit dem Sie Container-Images mit Harbor speichern und verwalten können.

Wenn Sie Harbor as a Service verwenden möchten, müssen Sie ein Harbor-Projekt in der tear-harbor-Registry-Instanz erstellen, um Ihre Container-Images zu verwalten:

Sie benötigen die URL von tear-harbor. Geben Sie die URL der Instanz an:
```
gdcloud harbor instances describe tear-harbor --project=tear
```
Die Ausgabe ähnelt harbor-1.org-1.zone1.google.gdc.test.
Legen Sie die Instanz-URL als Variable fest, die später in der Anleitung verwendet werden soll:
```
export INSTANCE_URL=INSTANCE_URL
```
Bevor Sie das Projekt erstellen, müssen Sie sich mit der URL aus dem vorherigen Schritt in Harbor anmelden. Öffnen Sie diese URL in einem Browser und melden Sie sich in der Harbor-Instanz an.
Harbor-Projekt erstellen:
```
gdcloud harbor harbor-projects create HARBOR_PROJECT \
    --project=tear \
    --instance=tear-harbor
```
Ersetzen Sie HARBOR_PROJECT durch den Namen des zu erstellenden Harbor-Projekts. Sie können das Harbor-Projekt nicht in einem beliebigen Projektnamespace erstellen. Sie müssen das Projekt tear verwenden.
Legen Sie den Namen des Harbor-Projekts als Variable fest, die Sie später in der Anleitung verwenden können:
```
export HARBOR_PROJECT=HARBOR_PROJECT
```

Docker konfigurieren

Führen Sie die folgenden Schritte aus, um Docker in Ihrer Harbor-Registry zu verwenden:

Konfigurieren Sie Docker so, dass Harbor als Dienst vertraut wird. Weitere Informationen finden Sie unter Docker so konfigurieren, dass die Harbor-Stammzertifizierungsstelle vertrauenswürdig ist.
Konfigurieren Sie die Docker-Authentifizierung für Harbor. Weitere Informationen finden Sie unter Docker-Authentifizierung für Harbor-Registry-Instanzen konfigurieren.
Da tear-harbor eine vorkonfigurierte Harbor-Registrierung ist, müssen Sie dem Zertifikat vertrauen, das von der internen CA von Google Distributed Cloud Air-gapped signiert wurde:
1. Bitten Sie Ihren IO um die folgenden Informationen:
  1. die externe URL des Harbor-Clusters.
  2. Die Datei .crt der internen CA von Google Distributed Cloud mit Air Gap. Die Datei wird in der Regel in der Steuerungsebene als Secret mit dem Namen trust-store-internal-only im Namespace anthos-creds gespeichert.
2. Erstellen Sie wie im vorherigen Schritt einen Ordner mit dem Namen der externen URL des Harbor-Clusters und legen Sie die Datei .crt in diesem Ordner ab.

Kubernetes-Secret zum Abrufen von Images erstellen

Da Sie ein privates Harbor-Projekt verwenden, müssen Sie ein Kubernetes-Image-Pull-Secret erstellen.

Fügen Sie ein Roboterkonto für ein Harbor-Projekt hinzu. Folgen Sie der Anleitung in der Harbor-Benutzeroberfläche, um das Roboterkonto zu erstellen und das geheime Roboter-Token zu kopieren: https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#add-a-robot-account.
Notieren Sie sich den Namen des neuen Robot-Projektkontos. Er hat die folgende Syntax:
```
<PREFIX><PROJECT_NAME>+<ACCOUNT_NAME>
```
Der Name des Robot-Projektkontos hat beispielsweise das Format harbor@library+artifact-account.

Weitere Informationen zum Suchen des Kontonamens Ihres Roboterprojekts in Harbor finden Sie in der Harbor-Dokumentation: https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#view-project-robot-accounts.
Melden Sie sich mit dem Roboterkonto und dem geheimen Token Ihres Harbor-Projekts bei Docker an:
```
docker login ${INSTANCE_URL}
```
Geben Sie bei Aufforderung den Namen des Robot-Projektkontos für Username und das geheime Token für Password ein.
Legen Sie einen beliebigen Namen für das Image-Pull-Secret fest:
```
export SECRET=SECRET
```
Erstellen Sie das für das Pullen des Images erforderliche Secret:
```
kubectl create secret docker-registry ${SECRET}  \
    --from-file=.dockerconfigjson=DOCKER_CONFIG \
    -n NAMESPACE
```
Ersetzen Sie Folgendes:
- DOCKER_CONFIG: der Pfad zur Datei .docker/config.json.
- NAMESPACE: der Namespace für das Secret, das Sie erstellen.

Container-Image per Push an die verwaltete Harbor-Registry übertragen

In dieser Anleitung laden Sie das nginx-Webserver-Image herunter und übertragen es in die verwaltete Harbor-Registry. Anschließend verwenden Sie es, um eine Beispiel-App für den nginx-Webserver in einem Kubernetes-Cluster bereitzustellen. Die Nginx-Webserver-App ist in der öffentlichen Google Cloud Artifact Registry verfügbar.

Laden Sie das nginx-Image aus der Google Cloud Artifact Registry über ein externes Netzwerk auf Ihre lokale Workstation herunter:
```
docker pull gcr.io/cloud-marketplace/google/nginx:1.25
```
Legen Sie den Namen des Bildes fest. Der vollständige Image-Name hat folgendes Format:
```
${INSTANCE_URL}/${HARBOR_PROJECT}/nginx
```

Taggen Sie das lokale Image mit dem Repository-Namen:

docker tag gcr.io/cloud-marketplace/google/nginx:1.25 ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25

Übertragen Sie das nginx-Container-Image per Push an Ihre verwaltete Harbor-Registry:
```
docker push ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
```

Beispielcontainer-App bereitstellen

Sie können das nginx-Container-Image jetzt im Appliance-Cluster bereitstellen.

Kubernetes stellt Anwendungen als Pod-Ressourcen dar. Dies sind skalierbare Einheiten, die einen oder mehrere Container enthalten. Der Pod ist die kleinste bereitstellbare Einheit in Kubernetes. In der Regel werden Pods als eine Reihe von Replikaten bereitgestellt, die skaliert und über den Cluster verteilt werden können. Eine Möglichkeit, einen Satz von Replikaten bereitzustellen, ist ein Kubernetes-Deployment.

In diesem Abschnitt erstellen Sie ein Kubernetes-Deployment, um die nginx-Containeranwendung in Ihrem Cluster auszuführen. Dieses Deployment hat Replikate oder Pods. Ein Deployment-Pod enthält nur einen Container: das nginx-Container-Image. Außerdem erstellen Sie eine Service-Ressource, die Clients eine stabile Möglichkeit bietet, Anfragen an die Pods Ihres Deployment zu senden.

Stellen Sie den Nginx-Webserver bereit:

Erstellen und stellen Sie die benutzerdefinierten Kubernetes-Ressourcen Deployment und Service bereit:

kubectl --kubeconfig ${KUBECONFIG} -n ${NAMESPACE} \
create -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
        ports:
        - containerPort: 80
      imagePullSecrets:
      - name: ${SECRET}
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - port: 80
      protocol: TCP
  type: LoadBalancer
EOF

Prüfen Sie, ob die Pods von der Bereitstellung erstellt wurden:

kubectl get pods -l app=nginx -n ${NAMESPACE}

Die Ausgabe sieht etwa so aus:

NAME                                READY     STATUS    RESTARTS   AGE
nginx-deployment-1882529037-6p4mt   1/1       Running   0          1h
nginx-deployment-1882529037-p29za   1/1       Running   0          1h
nginx-deployment-1882529037-s0cmt   1/1       Running   0          1h

Erstellen Sie eine Netzwerkrichtlinie, um den gesamten Netzwerk-Traffic zum Namespace zuzulassen:

kubectl --kubeconfig ${KUBECONFIG} -n ${NAMESPACE} \
create -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  annotations:
  name: allow-all
spec:
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
  podSelector: {}
  policyTypes:
  - Ingress
EOF

Exportieren Sie die IP-Adresse für den nginx-Dienst:

  export IP=`kubectl --kubeconfig=${KUBECONFIG} get service nginx-service \
      -n ${NAMESPACE} -o jsonpath='{.status.loadBalancer.ingress[*].ip}'`

Testen Sie die nginx-Server-IP-Adresse mit curl:
```
  curl http://$IP
```

Nächste Schritte

Informationen zum Verwalten von Containern finden Sie in der Dokumentation zu Containern.