Container-Webserveranwendung bereitstellen

Verwaltete Harbor-Registry erstellen

GDC Air-Gapped bietet Harbor as a Service, 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 zuerst eine Harbor-Registrierungsinstanz und ein Harbor-Projekt erstellen.

Harbor-Registry-Instanz erstellen

So erstellen Sie eine Harbor-Container-Registry-Instanz:

Harbor-Projekt in der Registry erstellen

Sie müssen ein Harbor-Projekt in der Harbor-Registry-Instanz erstellen, um Ihre Container-Images zu verwalten:

Docker konfigurieren

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

1. Konfigurieren Sie Docker so, dass Harbor als Dienst vertraut wird. Weitere Informationen finden Sie unter Docker so konfigurieren, dass der Harbor-Stammzertifizierungsstelle vertraut wird.

2. Konfigurieren Sie die Docker-Authentifizierung für Harbor. Weitere Informationen finden Sie unter Docker-Authentifizierung für Harbor-Registry-Instanzen konfigurieren.

Kubernetes-Secret zum Abrufen von Images erstellen

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

1. Fügen Sie ein Harbor-Projektroboterkonto als Dienstkonto hinzu.

   1. Wählen Sie in der Harbor-Konsole Ihr Harbor-Projekt aus.

   2. Klicken Sie auf Robot-Konten.

   3. Wählen Sie Neues Roboter-Konto aus.

   4. Geben Sie Ihrem neuen Roboter-Konto einen Namen und legen Sie zusätzliche Einstellungen fest.

   5. Klicken Sie auf Hinzufügen.

   6. Der Name und das Secret des Roboterkontos werden auf dem Erfolgsbildschirm angezeigt. Lassen Sie diesen Bildschirm für den nächsten Schritt geöffnet.

   Weitere Informationen finden Sie in der Dokumentation von Harbor: https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#add-a-robot-account.

2. Melden Sie sich in einem neuen Terminalfenster mit Ihrem Harbor-Projektroboterkonto und dem geheimen Token bei Docker an:

   docker login ${INSTANCE_URL}
   

   Geben Sie bei Aufforderung den Namen des Roboterprojekts für den Nutzernamen und das geheime Token für das Passwort ein, die im vorherigen Schritt auf dem Erfolgsbildschirm der Harbor-Konsole angegeben wurden.

3. Legen Sie einen beliebigen Namen für das Image-Pull-Secret fest:

   export SECRET=SECRET
   

4. 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 DOCKER_CONFIG durch den Pfad zur Datei .docker/config.json.

5. Prüfen Sie, ob Ihr Secret im Namespace Ihres GDC-Projekts vorhanden ist:

   kubectl get secrets -n ${NAMESPACE}
   

   Die Ausgabe sieht etwa so aus:

   NAME          TYPE                               DATA     AGE
   my-secret     kubernetes.io/dockerconfigjson     1        23s
   

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 im öffentlichen Docker Hub-Repository verfügbar.

1. Rufen Sie das nginx-Image über ein externes Netzwerk aus Docker Hub auf Ihre lokale Workstation ab:

   docker pull nginx
   

2. Taggen Sie das lokale Image mit dem Repository-Namen:

   docker tag nginx ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
   

3. Übertragen Sie das nginx-Container-Image per Push an Ihre verwaltete Harbor-Registry:

   docker push ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
   

Kubernetes-Cluster erstellen

Nachdem Sie das nginx-Container-Image in der verwalteten Harbor-Registry gespeichert haben und darauf zugreifen können, erstellen Sie einen Kubernetes-Cluster, um den nginx-Webserver auszuführen.

Weitere Informationen zum Erstellen eines Kubernetes-Clusters finden Sie unter Kubernetes-Cluster erstellen.

Beispielcontainer-App bereitstellen

Sie können jetzt das nginx-Container-Image in Ihrem Kubernetes-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 in Ihrem Kubernetes-Cluster bereit:

1. Melden Sie sich im Kubernetes-Cluster an und generieren Sie die kubeconfig-Datei mit einer Nutzeridentität. Legen Sie den kubeconfig-Pfad als Umgebungsvariable fest:

   export KUBECONFIG=CLUSTER_KUBECONFIG_PATH
   

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

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

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

5. 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}'`
   

6. Testen Sie die nginx-Server-IP-Adresse mit curl:

     curl http://$IP