TOC

So richten Sie eine private Docker-Registrierung auf DigitalOcean-Spaces ein und verwenden sie mit DigitalOcean-Kubernetes

Der Autor hat dieFree and Open Source Fundausgewählt, um eine Spende im Rahmen desWrite for DOnations-Programms zu erhalten.

Einführung

ADocker registry ist ein Speicher- und Inhaltsbereitstellungssystem für benannte Docker-Images, die den Industriestandard für containerisierte Anwendungen darstellen. Mit einer privaten Docker-Registrierung können Sie Ihre Bilder sicher in Ihrem Team oder Ihrer Organisation freigeben, und dies mit mehr Flexibilität und Kontrolle im Vergleich zu öffentlichen Bildern. Wenn Sie Ihre private Docker-Registrierung direkt in Ihrem Kubernetes-Cluster hosten, können Sie höhere Geschwindigkeiten, geringere Latenzzeiten und eine bessere Verfügbarkeit erzielen, während Sie gleichzeitig die Kontrolle über die Registrierung haben.

Der zugrunde liegende Registrierungsspeicher wird an externe Treiber delegiert. Das Standardspeichersystem ist das lokale Dateisystem. Sie können dieses jedoch gegen einen Cloud-basierten Speichertreiber austauschen. DigitalOcean Spaces ist ein S3-kompatibler Objektspeicher für Entwicklerteams und Unternehmen, die eine skalierbare, einfache und kostengünstige Möglichkeit zum Speichern und Bereitstellen großer Datenmengen suchen. Er eignet sich sehr gut zum Speichern von Docker-Bildern. Es verfügt über ein eingebautes CDN-Netzwerk, das die Latenz beim häufigen Zugriff auf Bilder erheblich reduzieren kann.

In diesem Lernprogramm stellen Sie Ihre private Docker-Registrierung mithilfe vonHelm in IhremDigitalOcean Kubernetes-Cluster bereit, der von DigitalOcean Spaces zum Speichern von Daten gesichert wird. Sie erstellen API-Schlüssel für den angegebenen Speicherplatz, installieren die Docker-Registrierung mit einer benutzerdefinierten Konfiguration in Ihrem Cluster, konfigurieren Kubernetes für die ordnungsgemäße Authentifizierung und testen sie, indem Sie eine Beispielbereitstellung im Cluster ausführen. Am Ende dieses Lernprogramms wird auf Ihrem DigitalOcean Kubernetes-Cluster eine sichere, private Docker-Registrierung installiert.

Voraussetzungen

Bevor Sie mit diesem Lernprogramm beginnen, benötigen Sie Folgendes:

  • Docker ist auf dem Computer installiert, von dem aus Sie auf Ihren Cluster zugreifen. Für Ubuntu 18.04 besuchen SieHow To Install and Use Docker on Ubuntu 18.04. Sie müssen nur den ersten Schritt ausführen. Andernfalls besuchen Sie Dockerswebsite für andere Distributionen.

  • Ein DigitalOcean Kubernetes-Cluster, dessen Verbindungskonfiguration als Standardwert fürkubectlkonfiguriert ist. Anweisungen zum Konfigurieren vonkubectl finden Sie unter dem SchrittConnect to your Cluster, der beim Erstellen Ihres Clusters angezeigt wird. Informationen zum Erstellen eines Kubernetes-Clusters in DigitalOcean finden Sie unterKubernetes Quickstart.

  • Ein DigitalOcean Space mit API-Schlüsseln (Zugriff und Geheimnis). Informationen zum Erstellen eines DigitalOcean Space und von API-Schlüsseln finden Sie unterHow To Create a DigitalOcean Space and API Key.

  • Der Helm-Paket-Manager ist auf Ihrem lokalen Computer installiert, und Tiller ist auf Ihrem Cluster installiert. Führen Sie die Schritte 1 und 2 derHow To Install Software on Kubernetes Clusters with the Helm Package Manager aus. Sie müssen nur die ersten beiden Schritte ausführen.

  • Der auf dem Cluster installierte Nginx Ingress Controller und Cert-Manager. Eine Anleitung dazu finden Sie unterHow to Set Up an Nginx Ingress with Cert-Manager on DigitalOcean Kubernetes.

  • Ein Domänenname mit zwei DNS-A-Einträgen verweist auf den von Ingress verwendeten DigitalOcean Load Balancer. Wenn Sie die DNS-Einträge Ihrer Domain mit DigitalOcean verwalten, konsultieren SieHow to Manage DNS Records, um A-Einträge zu erstellen. In diesem Lernprogramm werden die A-Datensätze alsregistry.example.com undk8s-test.example.com bezeichnet.

[[Schritt 1 - Konfigurieren und Installieren der Docker-Registrierung]] == Schritt 1 - Konfigurieren und Installieren der Docker-Registrierung

In diesem Schritt erstellen Sie eine Konfigurationsdatei für die Registrierungsbereitstellung und installieren die Docker-Registrierung mit der angegebenen Konfiguration unter Verwendung des Helm-Paketmanagers in Ihrem Cluster.

Im Verlauf dieses Lernprogramms verwenden Sie eine Konfigurationsdatei mit dem Namenchart_values.yaml, um einige der Standardeinstellungen für die Docker-Registrierung Helmchart zu überschreiben. Helm nennt seine Pakete, Charts; Hierbei handelt es sich um Dateigruppen, die eine verwandte Auswahl von Kubernetes-Ressourcen beschreiben. Sie bearbeiten die Einstellungen, um DigitalOcean Spaces als zugrunde liegendes Speichersystem festzulegen und den HTTPS-Zugriff zu aktivieren, indem Sie die Verbindung zu Let's Encrypt TLS-Zertifikaten herstellen.

Als Teil der Voraussetzung hätten Sie die Diensteecho1 undecho2 und einenecho_ingress-Eingang zu Testzwecken erstellt. Sie werden diese in diesem Tutorial nicht benötigen, sodass Sie sie jetzt löschen können.

Beginnen Sie mit dem Löschen des Eingangs, indem Sie den folgenden Befehl ausführen: 

kubectl delete -f echo_ingress.yaml

Löschen Sie dann die beiden Testdienste: 

kubectl delete -f echo1.yaml && kubectl delete -f echo2.yaml

Der Befehl kubectldelete akzeptiert die zu löschende Datei, wenn der Parameter-f übergeben wird.

Erstellen Sie einen Ordner, der als Arbeitsbereich dient: 

mkdir ~/k8s-registry

Navigieren Sie dorthin, indem Sie Folgendes ausführen: 

cd ~/k8s-registry

Erstellen Sie nun mit Ihrem Texteditor die Dateichart_values.yaml: 

nano chart_values.yaml

Fügen Sie die folgenden Zeilen hinzu, und stellen Sie sicher, dass Sie die hervorgehobenen Zeilen durch Ihre Daten ersetzen:

chart_values.yaml

ingress:
  enabled: true
  hosts:
    - registry.example.com
  annotations:
    kubernetes.io/ingress.class: nginx
    certmanager.k8s.io/cluster-issuer: letsencrypt-prod
    nginx.ingress.kubernetes.io/proxy-body-size: "30720m"
  tls:
    - secretName: letsencrypt-prod
      hosts:
        - registry.example.com

storage: s3

secrets:
  htpasswd: ""
  s3:
    accessKey: "your_space_access_key"
    secretKey: "your_space_secret_key"

s3:
  region: your_space_region
  regionEndpoint: your_space_region.digitaloceanspaces.com
  secure: true
  bucket: your_space_name

Der erste Block,ingress, konfiguriert den Kubernetes Ingress, der als Teil der Helmdiagrammbereitstellung erstellt wird. Das Ingress-Objekt bewirkt, dass externe HTTP / HTTPS-Routen auf interne Dienste im Cluster verweisen, sodass die Kommunikation von außen möglich ist. Die überschriebenen Werte sind:

  • enabled: Auftrue setzen, um den Eingang zu aktivieren.

  • hosts: Eine Liste der Hosts, von denen der Ingress Datenverkehr akzeptiert.

  • annotations: Eine Liste von Metadaten, die anderen Teilen von Kubernetes weitere Anweisungen zur Behandlung des Eingangs geben. Sie setzen den Ingress Controller aufnginx, den Let's Encrypt-Cluster-Aussteller auf die Produktionsvariante (letsencrypt-prod) und weisen dennginx-Controller an, Dateien mit einer maximalen Größe von 30 GB zu akzeptieren ist eine sinnvolle Grenze für selbst die größten Docker-Bilder.

  • tls: Diese Unterkategorie konfiguriert Let's Encrypt HTTPS. Sie füllen die Listehostsmit der Liste, von welchen sicheren Hosts dieser Ingress HTTPS-Verkehr mit unserem Beispieldomänennamen akzeptiert.

Dann setzen Sie den Dateisystemspeicher aufs3 - die andere verfügbare Option wärefilesystem. Hier gibts3 die Verwendung eines Remote-Speichersystems an, das mit der branchenüblichen Amazon S3-API kompatibel ist, die DigitalOcean Spaces erfüllt.

Im nächsten Block,secrets, konfigurieren Sie Schlüssel für den Zugriff auf Ihren DigitalOcean Space unter der Unterkategories3. Schließlich konfigurieren Sie im Blocks3 die Parameter, die Ihren Space angeben.

Speichern und schließen Sie Ihre Datei.

Wenn Sie dies noch nicht getan haben, richten Sie Ihre A-Datensätze so ein, dass sie auf den Load Balancer verweisen, den Sie als Teil der Nginx Ingress Controller-Installation im vorausgesetzten Lernprogramm erstellt haben. Informationen zum Einstellen Ihres DNS auf DigitalOcean finden Sie unterHow to Manage DNS Records.

Stellen Sie als Nächstes sicher, dass Ihr Space nicht leer ist. Die Docker-Registrierung wird überhaupt nicht ausgeführt, wenn Sie keine Dateien in Ihrem Space haben. Laden Sie eine Datei hoch, um dies zu umgehen. Navigieren Sie zur Registerkarte "Leerzeichen", suchen Sie Ihr Leerzeichen, klicken Sie auf die Schaltfläche "Upload File" und laden Sie eine beliebige Datei hoch. Sie können die gerade erstellte Konfigurationsdatei hochladen.

Empty file uploaded to empty Space

Bevor Sie etwas über Helm installieren, müssen Sie den Cache aktualisieren. Dadurch werden die neuesten Informationen zu Ihrem Karten-Repository aktualisiert. Führen Sie dazu den folgenden Befehl aus: 

helm repo update

Jetzt stellen Sie das Docker-Registrierungsdiagramm mit dieser benutzerdefinierten Konfiguration über Helm bereit, indem Sie Folgendes ausführen: 

helm install stable/docker-registry -f chart_values.yaml --name docker-registry

Sie sehen die folgende Ausgabe: 

OutputNAME:   docker-registry
...
NAMESPACE: default
STATUS: DEPLOYED

RESOURCES:
==> v1/ConfigMap
NAME                    DATA  AGE
docker-registry-config  1     1s

==> v1/Pod(related)
NAME                              READY  STATUS             RESTARTS  AGE
docker-registry-54df68fd64-l26fb  0/1    ContainerCreating  0         1s

==> v1/Secret
NAME                    TYPE    DATA  AGE
docker-registry-secret  Opaque  3     1s

==> v1/Service
NAME             TYPE       CLUSTER-IP      EXTERNAL-IP  PORT(S)   AGE
docker-registry  ClusterIP  10.245.131.143         5000/TCP  1s

==> v1beta1/Deployment
NAME             READY  UP-TO-DATE  AVAILABLE  AGE
docker-registry  0/1    1           0          1s

==> v1beta1/Ingress
NAME             HOSTS                 ADDRESS  PORTS  AGE
docker-registry  registry.example.com  80, 443  1s


NOTES:
1. Get the application URL by running these commands:
  https://registry.example.com/

Helm listet alle Ressourcen auf, die als Ergebnis der Bereitstellung des Docker-Registrierungsdiagramms erstellt wurden. Auf die Registrierung kann jetzt über den zuvor angegebenen Domänennamen zugegriffen werden.

Sie haben eine Docker-Registrierung in Ihrem Kubernetes-Cluster konfiguriert und bereitgestellt. Als Nächstes testen Sie die Verfügbarkeit der neu bereitgestellten Docker-Registrierung.

[[Schritt-2 - Testen des Drückens und Ziehens]] == Schritt 2 - Testen des Drückens und Ziehens

In diesem Schritt testen Sie Ihre neu bereitgestellte Docker-Registrierung, indem Sie Bilder von und zu dieser ziehen und verschieben. Derzeit ist die Registrierung leer. Damit Sie etwas verschieben können, muss auf dem Computer, auf dem Sie arbeiten, ein Bild verfügbar sein. Verwenden wir das Docker-Image vonmysql.

Beginnen Sie, indem Siemysql vom Docker Hub abrufen: 

sudo docker pull mysql

Ihre Ausgabe sieht folgendermaßen aus: 

OutputUsing default tag: latest
latest: Pulling from library/mysql
27833a3ba0a5: Pull complete
...
e906385f419d: Pull complete
Digest: sha256:a7cf659a764732a27963429a87eccc8457e6d4af0ee9d5140a3b56e74986eed7
Status: Downloaded newer image for mysql:latest

Sie haben jetzt das Bild lokal verfügbar. Um Docker darüber zu informieren, wo es abgelegt werden soll, müssen Sie es mit dem Hostnamen wie folgt versehen: 

sudo docker tag mysql registry.example.com/mysql

Dann verschieben Sie das Bild in die neue Registrierung: 

sudo docker push registry.example.com/mysql

Dieser Befehl wird erfolgreich ausgeführt und zeigt an, dass Ihre neue Registrierung ordnungsgemäß konfiguriert ist und Datenverkehr akzeptiert - einschließlich des Push-Vorgangs für neue Bilder. Wenn Sie einen Fehler sehen, überprüfen Sie Ihre Schritte anhand der Schritte 1 und 2.

Um das saubere Abrufen aus der Registrierung zu testen, löschen Sie zuerst die lokalenmysql-Bilder mit dem folgenden Befehl: 

sudo docker rmi registry.example.com/mysql && sudo docker rmi mysql

Dann ziehen Sie es aus der Registrierung: 

sudo docker pull registry.example.com/mysql

Dieser Befehl dauert einige Sekunden. Wenn es erfolgreich ausgeführt wird, bedeutet dies, dass Ihre Registrierung ordnungsgemäß funktioniert. Wenn ein Fehler angezeigt wird, überprüfen Sie Ihre Eingaben anhand der vorherigen Befehle.

Sie können lokal verfügbare Docker-Images auflisten, indem Sie den folgenden Befehl ausführen: 

sudo docker images

In der Ausgabe werden die auf Ihrem lokalen Computer verfügbaren Bilder mit ihrer ID und dem Erstellungsdatum aufgelistet.

Ihre Docker-Registrierung ist konfiguriert. Sie haben ein Bild darauf verschoben und festgestellt, dass Sie es nach unten ziehen können. Fügen wir nun die Authentifizierung hinzu, damit nur bestimmte Personen auf den Code zugreifen können.

[[Schritt 3 - Hinzufügen der Kontoauthentifizierung und Konfigurieren des Kubernetes-Zugriffs] == Schritt 3 - Hinzufügen der Kontoauthentifizierung und Konfigurieren des Kubernetes-Zugriffs

In diesem Schritt richten Sie die Authentifizierung mit Benutzername und Kennwort für die Registrierung mit dem Dienstprogrammhtpasswdein.

Das Dienstprogrammhtpasswdtammt vom Apache-Webserver, mit dem Sie Dateien erstellen können, in denen Benutzernamen und Kennwörter für die grundlegende Authentifizierung von HTTP-Benutzern gespeichert sind. Das Format derhtpasswd-Dateien istusername:hashed_password (eine pro Zeile), das portabel genug ist, damit auch andere Programme es verwenden können.

Umhtpasswd auf dem System verfügbar zu machen, müssen Sie es installieren, indem Sie Folgendes ausführen: 

sudo apt install apache2-utils -y

[.Hinweis]##

Note:
Wenn Sie dieses Lernprogramm von einem Mac aus ausführen, müssen Sie den folgenden Befehl verwenden, umhtpasswd auf Ihrem Computer verfügbar zu machen: 

docker run --rm -v ${PWD}:/app -it httpd htpasswd -b -c /app/htpasswd_file sammy password

Erstellen Sie es, indem Sie den folgenden Befehl ausführen: 

touch htpasswd_file

Fügen Siehtpasswd_file eine Kombination aus Benutzername und Passwort hinzu: 

htpasswd -B htpasswd_file username

Docker verlangt, dass das Passwort mit dembcrypt-Algorithmus gehasht wird, weshalb wir den-B-Parameter übergeben. Der bcrypt-Algorithmus ist eine Passwort-Hashing-Funktion, die auf der Blowfish-Blockverschlüsselung basiert und einenwork factor-Parameter enthält, der angibt, wie teuer die Hash-Funktion sein wird.

Denken Sie daran,username durch Ihren gewünschten Benutzernamen zu ersetzen. Beim Ausführen werden Sie vonhtpasswd nach dem zugehörigen Kennwort gefragt und die Kombination zuhtpasswd_file hinzugefügt. Sie können diesen Befehl für so viele Benutzer wiederholen, wie Sie hinzufügen möchten.

Zeigen Sie nun den Inhalt vonhtpasswd_file an, indem Sie den folgenden Befehl ausführen: 

cat htpasswd_file

Wählen Sie den angezeigten Inhalt aus und kopieren Sie ihn.

Um Ihrer Docker-Registrierung eine Authentifizierung hinzuzufügen, müssen Siechart_values.yaml bearbeiten und den Inhalt vonhtpasswd_file in die Variablehtpasswd einfügen.

Öffnen Siechart_values.yaml zum Bearbeiten: 

nano chart_values.yaml

Suchen Sie die Zeile, die so aussieht:

chart_values.yaml

  htpasswd: ""

Bearbeiten Sie es so, dass es mit dem folgenden übereinstimmt, und ersetzen Siehtpasswd\_file\_contents durch den Inhalt, den Sie aushtpasswd_file kopiert haben:

chart_values.yaml

  htpasswd: |-
    htpasswd_file_contents

Seien Sie vorsichtig mit dem Einzug, jede Zeile des Dateiinhalts muss vier Leerzeichen vor sich haben.

Speichern und schließen Sie die Datei, nachdem Sie den Inhalt hinzugefügt haben.

Führen Sie den folgenden Befehl aus, um die Änderungen an Ihren Cluster weiterzugeben: 

helm upgrade docker-registry stable/docker-registry -f chart_values.yaml

Die Ausgabe ähnelt der bei der ersten Bereitstellung Ihrer Docker-Registrierung angezeigten: 

OutputRelease "docker-registry" has been upgraded. Happy Helming!
LAST DEPLOYED: ...
NAMESPACE: default
STATUS: DEPLOYED

RESOURCES:
==> v1/ConfigMap
NAME                    DATA  AGE
docker-registry-config  1     3m8s

==> v1/Pod(related)
NAME                              READY  STATUS   RESTARTS  AGE
docker-registry-6c5bb7ffbf-ltnjv  1/1    Running  0         3m7s

==> v1/Secret
NAME                    TYPE    DATA  AGE
docker-registry-secret  Opaque  4     3m8s

==> v1/Service
NAME             TYPE       CLUSTER-IP      EXTERNAL-IP  PORT(S)   AGE
docker-registry  ClusterIP  10.245.128.245         5000/TCP  3m8s

==> v1beta1/Deployment
NAME             READY  UP-TO-DATE  AVAILABLE  AGE
docker-registry  1/1    1           1          3m8s

==> v1beta1/Ingress
NAME             HOSTS                ADDRESS        PORTS    AGE
docker-registry  registry.example.com  159.89.215.50  80, 443  3m8s


NOTES:
1. Get the application URL by running these commands:
  https://registry.example.com/

Dieser Befehl ruft Helm auf und weist ihn an, eine vorhandene Version, in Ihrem Falldocker-registry, zu aktualisieren, deren Diagramm instable/docker-registry im Diagrammrepository definiert ist, nachdem die Dateichart_values.yaml angewendet wurde.

Jetzt versuchen Sie erneut, ein Bild aus der Registrierung zu ziehen: 

sudo docker pull registry.example.com/mysql

Die Ausgabe sieht folgendermaßen aus: 

OutputUsing default tag: latest
Error response from daemon: Get https://registry.example.com/v2/mysql/manifests/latest: no basic auth credentials

Es ist korrekt fehlgeschlagen, da Sie keine Anmeldeinformationen angegeben haben. Dies bedeutet, dass Ihre Docker-Registrierung Anfragen korrekt autorisiert.

Führen Sie den folgenden Befehl aus, um sich bei der Registrierung anzumelden: 

sudo docker login registry.example.com

Denken Sie daran,registry.example.com durch Ihre Domain-Adresse zu ersetzen. Sie werden aufgefordert, einen Benutzernamen und ein Passwort einzugeben. Wenn ein Fehler angezeigt wird, überprüfen Sie noch einmal, was Ihrehtpasswd_fileenthalten. Sie müssen die Kombination aus Benutzername und Kennwort inhtpasswd_file definieren, die Sie zuvor in diesem Schritt erstellt haben.

Um die Anmeldung zu testen, können Sie versuchen, sie erneut abzurufen, indem Sie den folgenden Befehl ausführen: 

sudo docker pull registry.example.com/mysql

Die Ausgabe sieht ungefähr so ​​aus: 

OutputUsing default tag: latest
latest: Pulling from mysql
Digest: sha256:f2dc118ca6fa4c88cde5889808c486dfe94bccecd01ca626b002a010bb66bcbe
Status: Image is up to date for registry.example.com/mysql:latest

Sie haben Docker jetzt konfiguriert und können sich sicher anmelden. Führen Sie den folgenden Befehl aus, um Kubernetes für die Anmeldung bei Ihrer Registrierung zu konfigurieren: 

sudo kubectl create secret generic regcred --from-file=.dockerconfigjson=/home/sammy/.docker/config.json --type=kubernetes.io/dockerconfigjson

Sie werden die folgende Ausgabe sehen: 

Outputsecret/regcred created

Dieser Befehl erstellt ein Geheimnis in Ihrem Cluster mit dem Namenregcred, nimmt den Inhalt der JSON-Datei, in der Docker die Anmeldeinformationen speichert, und analysiert ihn alsdockerconfigjson, wodurch ein Registrierungsnachweis in Kubernetes definiert wird.

Sie habenhtpasswd verwendet, um eine Anmeldekonfigurationsdatei zu erstellen, die Registrierung für die Authentifizierung von Anforderungen konfiguriert und ein Kubernetes-Geheimnis mit den Anmeldeinformationen erstellt. Als Nächstes testen Sie die Integration zwischen Ihrem Kubernetes-Cluster und der Registrierung.

[[Schritt 4 - Testen der Kubernetes-Integration durch Ausführen einer Beispielbereitstellung] == Schritt 4 - Testen der Kubernetes-Integration durch Ausführen einer Beispielbereitstellung

In diesem Schritt führen Sie eine Beispielbereitstellung mit einem in der clusterinternen Registrierung gespeicherten Image aus, um die Verbindung zwischen Ihrem Kubernetes-Cluster und der Registrierung zu testen.

Im letzten Schritt haben Sie ein Geheimnis namensregcred erstellt, das Anmeldeinformationen für Ihre private Registrierung enthält. Es kann Anmeldeinformationen für mehrere Registrierungen enthalten. In diesem Fall müssen Sie das Secret entsprechend aktualisieren.

Sie können angeben, welche geheimen Kubernetes beim Abrufen von Containern in der Pod-Definition verwendet werden sollen, indem SieimagePullSecrets angeben. Dieser Schritt ist erforderlich, wenn die Docker-Registrierung eine Authentifizierung erfordert.

Sie stellen jetzt ein BeispielHello World image aus Ihrer privaten Docker-Registrierung in Ihrem Cluster bereit. Um es zu pushen, ziehen Sie es zunächst auf Ihren Computer, indem Sie den folgenden Befehl ausführen: 

sudo docker pull paulbouwer/hello-kubernetes:1.5

Dann markieren Sie es mit: 

sudo docker tag paulbouwer/hello-kubernetes:1.5 registry.example.com/paulbouwer/hello-kubernetes:1.5

Zum Schluss pushen Sie es in Ihre Registry: 

sudo docker push registry.example.com/paulbouwer/hello-kubernetes:1.5

Löschen Sie es von Ihrem Computer, da Sie es lokal nicht mehr benötigen: 

sudo docker rmi registry.example.com/paulbouwer/hello-kubernetes:1.5

Jetzt stellen Sie die Beispielanwendung "Hello World" bereit. Erstellen Sie zunächst mit Ihrem Texteditor eine neue Datei,hello-world.yaml: 

nano hello-world.yaml

Als Nächstes definieren Sie einen Service und einen Ingress, um die App außerhalb des Clusters verfügbar zu machen. Fügen Sie die folgenden Zeilen hinzu und ersetzen Sie die hervorgehobenen Zeilen durch Ihre Domains:

hello-world.yaml

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: hello-kubernetes-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: k8s-test.example.com
    http:
      paths:
      - path: /
        backend:
          serviceName: hello-kubernetes
          servicePort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: hello-kubernetes
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: hello-kubernetes
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-kubernetes
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hello-kubernetes
  template:
    metadata:
      labels:
        app: hello-kubernetes
    spec:
      containers:
      - name: hello-kubernetes
        image: registry.example.com/paulbouwer/hello-kubernetes:1.5
        ports:
        - containerPort: 8080
      imagePullSecrets:
      - name: regcred

Zunächst definieren Sie den Ingress für die Hello World-Bereitstellung, die Sie über den Load Balancer weiterleiten, über den der Nginx Ingress Controller verfügt. Anschließend definieren Sie einen Service, der auf die in der Bereitstellung erstellten Pods zugreifen kann. In der tatsächlichen Bereitstellungsspezifikation geben Sieimage als das in Ihrer Registrierung befindliche an und setzenimagePullSecrets aufregcred, die Sie im vorherigen Schritt erstellt haben.

Speichern und schließen Sie die Datei. Führen Sie den folgenden Befehl aus, um dies in Ihrem Cluster bereitzustellen: 

kubectl apply -f hello-world.yaml

Sie sehen die folgende Ausgabe: 

Outputingress.extensions/hello-kubernetes-ingress created
service/hello-kubernetes created
deployment.apps/hello-kubernetes created

Sie können jetzt zu Ihrer Testdomäne navigieren - dem zweiten A-Datensatz,k8s-test.example.com in diesem Lernprogramm. Sie sehen die Seite von KubernetesHello world!.

Hello World page

Auf der Seite "Hallo Welt" werden einige Umgebungsinformationen aufgeführt, z. B. die Linux-Kernelversion und die interne ID des Pods, von dem aus die Anforderung gesendet wurde. Sie können auch über die Weboberfläche auf Ihren Space zugreifen, um die Bilder anzuzeigen, mit denen Sie in diesem Lernprogramm gearbeitet haben.

Wenn Sie diese Hello World-Bereitstellung nach dem Testen löschen möchten, führen Sie den folgenden Befehl aus: 

kubectl delete -f hello-world.yaml

Sie haben eine Hello World-Beispielbereitstellung erstellt, um zu testen, ob Kubernetes Bilder ordnungsgemäß aus Ihrer privaten Registrierung abruft.

Fazit

Sie haben jetzt erfolgreich Ihre eigene private Docker-Registrierung in Ihrem DigitalOcean Kubernetes-Cluster bereitgestellt und DigitalOcean Spaces als Speicherschicht darunter verwendet. Die Anzahl der Bilder, die Sie speichern können, ist unbegrenzt. Spaces können unbegrenzt erweitert werden und bieten gleichzeitig die gleiche Sicherheit und Robustheit. In der Produktion sollten Sie sich jedoch stets bemühen, Ihre Docker-Images so weit wie möglich zu optimieren. Schauen Sie sich das Tutorial vonHow To Optimize Docker Images for Productionan.

Related