Einrichten eines Nginx Ingress auf DigitalOcean-Kubernetes mit Helm

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

Einführung

KubernetesIngresses bieten Ihnen eine flexible Möglichkeit, Datenverkehr von außerhalb Ihres Clusters zu internen Kubernetes-Diensten weiterzuleiten. IngressResources sind Objekte in Kubernetes, die Regeln für das Weiterleiten von HTTP- und HTTPS-Verkehr an Dienste definieren. Damit diese funktionieren, muss ein IngressController vorhanden sein. Seine Aufgabe besteht darin, die Regeln zu implementieren, indem Datenverkehr (höchstwahrscheinlich über einen Load Balancer) akzeptiert und an die entsprechenden Dienste weitergeleitet wird. Die meisten Ingress Controller verwenden nur einen globalen Load Balancer für alle Ingresses. Dies ist effizienter als die Erstellung eines Load Balancers für jeden Service, den Sie verfügbar machen möchten.

Helm ist ein Paketmanager zum Verwalten von Kubernetes. Die Verwendung von Helm-Diagrammen mit Ihren Kubernetes bietet Konfigurierbarkeit und Lebenszyklusverwaltung zum Aktualisieren, Zurücksetzen und Löschen einer Kubernetes-Anwendung.

In diesem Handbuch richten Sie die von Kubernetes verwaltetenNginx Ingress Controllermit Helm ein. Anschließend erstellen Sie eine Ingress-Ressource, um den Datenverkehr von Ihren Domains an die Back-End-Dienste von Hello World weiterzuleiten. Sobald Sie den Ingress eingerichtet haben, installieren SieCert-Manager in Ihrem Cluster, um automatisch Let's Encrypt TLS-Zertifikate zur Sicherung Ihrer Ingresses bereitstellen zu können.

Voraussetzungen

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.
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 des Lernprogramms vonHow To Install Software on Kubernetes Clusters with the Helm Package Manageraus.
Ein vollständig registrierter Domainname mit zwei verfügbaren A-Einträgen. In diesem Tutorial werden durchgehendhw1.example.com undhw2.example.com verwendet. Sie können einen Domainnamen fürNamecheap kaufen, einen fürFreenom kostenlos erhalten oder den Domain-Registrar Ihrer Wahl verwenden.

[[Schritt-1 - Einrichten von Hallo-Welt-Bereitstellungen]] == Schritt 1 - Einrichten von Hallo-Welt-Bereitstellungen

In diesem Abschnitt stellen Sie vor der Bereitstellung von Nginx Ingress eine Hello World-App mit dem Namenhello-kubernetes bereit, um einige Dienste bereitzustellen, an die Sie den Datenverkehr weiterleiten. Um zu bestätigen, dass der Nginx Ingress in den nächsten Schritten ordnungsgemäß funktioniert, stellen Sie ihn zweimal mit einer anderen Willkommensnachricht bereit, die angezeigt wird, wenn Sie über Ihren Browser darauf zugreifen.

Sie speichern die Bereitstellungskonfiguration auf Ihrem lokalen Computer. Die erste Bereitstellungskonfiguration befindet sich in einer Datei mit dem Namenhello-kubernetes-first.yaml. Erstellen Sie es mit einem Texteditor:

nano hello-kubernetes-first.yaml

Fügen Sie die folgenden Zeilen hinzu:

hello-kubernetes-first.yaml

apiVersion: v1
kind: Service
metadata:
  name: hello-kubernetes-first
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: hello-kubernetes-first
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-kubernetes-first
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hello-kubernetes-first
  template:
    metadata:
      labels:
        app: hello-kubernetes-first
    spec:
      containers:
      - name: hello-kubernetes
        image: paulbouwer/hello-kubernetes:1.5
        ports:
        - containerPort: 8080
        env:
        - name: MESSAGE
          value: Hello from the first deployment!

Diese Konfiguration definiert eine Bereitstellung und einen Dienst. Die Bereitstellung besteht aus drei Replikaten des Images vonpaulbouwer/hello-kubernetes:1.5und einer Umgebungsvariablen mit dem NamenMESSAGE. Sie sehen ihren Wert, wenn Sie auf die App zugreifen. Der Dienst hier ist so definiert, dass die Bereitstellung im Cluster an Port80 verfügbar gemacht wird.

Speichern und schließen Sie die Datei.

Erstellen Sie dann diese erste Variante derhello-kubernetes-App in Kubernetes, indem Sie den folgenden Befehl ausführen:

kubectl create -f hello-kubernetes-first.yaml

Sie sehen die folgende Ausgabe:

Outputservice/hello-kubernetes-first created
deployment.apps/hello-kubernetes-first created

Führen Sie den folgenden Befehl aus, um die Erstellung des Dienstes zu überprüfen:

kubectl get service hello-kubernetes-first

Die Ausgabe sieht folgendermaßen aus:

OutputNAME                     TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
hello-kubernetes-first   ClusterIP   10.245.85.236           80:31623/TCP   35s

Sie werden sehen, dass dem neu erstellten Dienst eine Cluster-IP zugewiesen wurde, was bedeutet, dass er ordnungsgemäß funktioniert. Der gesamte an ihn gesendete Datenverkehr wird an die ausgewählte Bereitstellung an Port8080weitergeleitet. Nachdem Sie die erste Variante derhello-kubernetes-App bereitgestellt haben, arbeiten Sie an der zweiten.

Öffnen Sie eine Datei mit dem Namenhello-kubernetes-second.yaml zur Bearbeitung:

nano hello-kubernetes-second.yaml

Fügen Sie die folgenden Zeilen hinzu:

hello-kubernetes-second.yaml

apiVersion: v1
kind: Service
metadata:
  name: hello-kubernetes-second
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: hello-kubernetes-second
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-kubernetes-second
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hello-kubernetes-second
  template:
    metadata:
      labels:
        app: hello-kubernetes-second
    spec:
      containers:
      - name: hello-kubernetes
        image: paulbouwer/hello-kubernetes:1.5
        ports:
        - containerPort: 8080
        env:
        - name: MESSAGE
          value: Hello from the second deployment!

Speichern und schließen Sie die Datei.

Diese Variante hat den gleichen Aufbau wie die bisherige Konfiguration; Die einzigen Unterschiede bestehen in den Bereitstellungs- und Dienstnamen, um Kollisionen zu vermeiden, und in der Nachricht.

Erstellen Sie es nun in Kubernetes mit dem folgenden Befehl:

kubectl create -f hello-kubernetes-second.yaml

Die Ausgabe wird sein:

Outputservice/hello-kubernetes-second created
deployment.apps/hello-kubernetes-second created

Stellen Sie sicher, dass der zweite Dienst ausgeführt wird, indem Sie alle Ihre Dienste auflisten:

kubectl get service

Die Ausgabe wird ungefähr so aussehen:

OutputNAME                            TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)                      AGE
hello-kubernetes-first          ClusterIP      10.245.85.236              80:31623/TCP                 54s
hello-kubernetes-second         ClusterIP      10.245.99.130              80:30303/TCP                 12s
kubernetes                      ClusterIP      10.245.0.1                 443/TCP                      5m

Sowohlhello-kubernetes-first als auchhello-kubernetes-second werden aufgelistet, was bedeutet, dass Kubernetes sie erfolgreich erstellt hat.

Sie haben zwei Bereitstellungen derhello-kubernetes-App mit zugehörigen Diensten erstellt. In der Bereitstellungsspezifikation ist für jede Nachricht eine andere festgelegt, sodass Sie sie während des Tests unterscheiden können. Im nächsten Schritt installieren Sie den Nginx Ingress Controller selbst.

[[Schritt-2 - Installieren des Kubernetes-Nginx-Ingress-Controllers]] == Schritt 2 - Installieren des Kubernetes Nginx Ingress-Controllers

Jetzt installieren Sie die von Kubernetes gepflegtenNginx Ingress Controller mit Helm. Beachten Sie, dass es mehrereNginx Ingressesgibt.

Der Nginx Ingress Controller besteht aus einem Pod und einem Service. Auf dem Pod wird der Controller ausgeführt, der ständig den Endpunkt von/ingressesauf dem API-Server Ihres Clusters nach Updates für verfügbare Ingress-Ressourcen abfragt. Der Dienst ist vom Typ LoadBalancer. Da Sie ihn in einem DigitalOcean Kubernetes-Cluster bereitstellen, erstellt der Cluster automatisch einDigitalOcean Load Balancer, über das der gesamte externe Datenverkehr zum Controller fließt. Der Controller leitet den Datenverkehr dann an die entsprechenden Dienste weiter, wie in Ingress Resources definiert.

Nur der LoadBalancer-Dienst kennt die IP-Adresse des automatisch erstellten Load Balancer. Einige Apps (wieExternalDNS) müssen ihre IP-Adresse kennen, können jedoch nur die Konfiguration eines Ingress lesen. Der Controller kann so konfiguriert werden, dass die IP-Adresse bei jedem Eingang veröffentlicht wird, indem der Parametercontroller.publishService.enabled währendhelm install auftrue gesetzt wird. Es wird empfohlen, diese Einstellung zu aktivieren, um Anwendungen zu unterstützen, die möglicherweise von der IP-Adresse des Load Balancer abhängen.

Führen Sie den folgenden Befehl aus, um den Nginx Ingress Controller in Ihrem Cluster zu installieren:

helm install stable/nginx-ingress --name nginx-ingress --set controller.publishService.enabled=true

Dieser Befehl installiert den Nginx Ingress Controller aus dem Diagramm-Repository vonstable, benennt die Helm-Versionnginx-ingress und setzt den ParameterpublishService auftrue.

Die Ausgabe sieht folgendermaßen aus:

OutputNAME:   nginx-ingress
LAST DEPLOYED: ...
NAMESPACE: default
STATUS: DEPLOYED

RESOURCES:
==> v1/ConfigMap
NAME                      DATA  AGE
nginx-ingress-controller  1     0s

==> v1/Pod(related)
NAME                                            READY  STATUS             RESTARTS  AGE
nginx-ingress-controller-7658988787-npv28       0/1    ContainerCreating  0         0s
nginx-ingress-default-backend-7f5d59d759-26xq2  0/1    ContainerCreating  0         0s

==> v1/Service
NAME                           TYPE          CLUSTER-IP     EXTERNAL-IP  PORT(S)                     AGE
nginx-ingress-controller       LoadBalancer  10.245.9.107       80:31305/TCP,443:30519/TCP  0s
nginx-ingress-default-backend  ClusterIP     10.245.221.49         80/TCP                      0s

==> v1/ServiceAccount
NAME           SECRETS  AGE
nginx-ingress  1        0s

==> v1beta1/ClusterRole
NAME           AGE
nginx-ingress  0s

==> v1beta1/ClusterRoleBinding
NAME           AGE
nginx-ingress  0s

==> v1beta1/Deployment
NAME                           READY  UP-TO-DATE  AVAILABLE  AGE
nginx-ingress-controller       0/1    1           0          0s
nginx-ingress-default-backend  0/1    1           0          0s

==> v1beta1/Role
NAME           AGE
nginx-ingress  0s

==> v1beta1/RoleBinding
NAME           AGE
nginx-ingress  0s

NOTES:
...

Helm hat protokolliert, welche Ressourcen in Kubernetes im Rahmen der Diagramminstallation erstellt wurden.

Sie können sehen, wie der Load Balancer verfügbar wird, indem Sie Folgendes ausführen:

kubectl get services -o wide -w nginx-ingress-controller

Sie haben Nginx Ingress installiert, das von der Kubernetes-Community verwaltet wird. Es leitet HTTP- und HTTPS-Datenverkehr vom Load Balancer an die entsprechenden Back-End-Dienste weiter, die in Ingress Resources konfiguriert sind. Im nächsten Schritt stellen Sie die App-Bereitstellungen vonhello-kubernetesmithilfe einer Ingress-Ressource bereit.

[[Schritt 3 - Belichten der App mithilfe eines Eingangs]] == Schritt 3 - Belichten der App mithilfe eines Eingangs

Jetzt erstellen Sie eine Ingress-Ressource und verwenden sie, um die App-Bereitstellungen vonhello-kubernetesin Ihren gewünschten Domänen verfügbar zu machen. Sie können es dann testen, indem Sie über Ihren Browser darauf zugreifen.

Sie speichern den Ingress in einer Datei mit dem Namenhello-kubernetes-ingress.yaml. Erstellen Sie es mit Ihrem Editor:

nano hello-kubernetes-ingress.yaml

Fügen Sie Ihrer Datei die folgenden Zeilen hinzu:

hello-kubernetes-ingress.yaml

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: hello-kubernetes-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
  - host: hw1.example.com
    http:
      paths:
      - backend:
          serviceName: hello-kubernetes-first
          servicePort: 80
  - host: hw2.example.com
    http:
      paths:
      - backend:
          serviceName: hello-kubernetes-second
          servicePort: 80

Im obigen Code definieren Sie eine Ingress-Ressource mit dem Namenhello-kubernetes-ingress. Anschließend geben Sie zwei Hostregeln an, sodasshw1.example.com an den Diensthello-kubernetes-first undhw2.example.com ab der zweiten Bereitstellung (hello-kubernetes-second) an den Dienst weitergeleitet werden.

Denken Sie daran, die markierten Domänen durch Ihre eigenen zu ersetzen, und speichern und schließen Sie die Datei.

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

kubectl create -f hello-kubernetes-ingress.yaml

Als Nächstes müssen Sie sicherstellen, dass Ihre beiden Domänen über A-Datensätze auf den Load Balancer verweisen. Dies geschieht über Ihren DNS-Provider. Informationen zum Konfigurieren Ihrer DNS-Einträge in DigitalOcean finden Sie unterHow to Manage DNS Records.

Sie können jetzt in Ihrem Browser zuhw1.example.com navigieren. Sie werden folgendes sehen:

Hello Kubernetes - First Deployment

Die zweite Variante (hw2.example.com) zeigt eine andere Meldung:

Hello Kubernetes - Second Deployment

Damit haben Sie sichergestellt, dass der Ingress Controller Anforderungen korrekt weiterleitet. In diesem Fall von Ihren beiden Domänen zu zwei verschiedenen Diensten.

Sie haben eine Ingress-Ressource erstellt und konfiguriert, um die App-Bereitstellungen vonhello-kubernetesin Ihren Domänen bereitzustellen. Im nächsten Schritt richten Sie Cert-Manager ein, damit Sie Ihre Ingress-Ressourcen mit kostenlosen TLS-Zertifikaten von Let's Encrypt sichern können.

[[Schritt 4 - Sichern des Eingangs mit Cert-Manager]] == Schritt 4 - Sichern des Eingangs mit Cert-Manager

Um Ihre Ingress-Ressourcen zu schützen, installieren Sie Cert-Manager, erstellen einen ClusterIssuer für die Produktion und ändern die Konfiguration Ihres Ingress, um die TLS-Zertifikate zu nutzen. ClusterIssuers sind Cert-Manager-Ressourcen in Kubernetes, die TLS-Zertifikate bereitstellen. Nach der Installation und Konfiguration wird Ihre App hinter HTTPS ausgeführt.

Bevor Sie Cert-Manager über Helm in Ihrem Cluster installieren, wenden Sie die erforderlichenCRDs (benutzerdefinierte Ressourcendefinitionen) manuell aus dem Jetstack / Cert-Manager-Repository an, indem Sie den folgenden Befehl ausführen:

kubectl apply -f https://raw.githubusercontent.com/jetstack/cert-manager/release-0.8/deploy/manifests/00-crds.yaml

Sie werden die folgende Ausgabe sehen:

Outputcustomresourcedefinition.apiextensions.k8s.io/certificates.certmanager.k8s.io created
customresourcedefinition.apiextensions.k8s.io/challenges.certmanager.k8s.io created
customresourcedefinition.apiextensions.k8s.io/clusterissuers.certmanager.k8s.io created
customresourcedefinition.apiextensions.k8s.io/issuers.certmanager.k8s.io created
customresourcedefinition.apiextensions.k8s.io/orders.certmanager.k8s.io created

Dies zeigt, dass Kubernetes die benutzerdefinierten Ressourcen angewendet hat, die Sie für cert-manager benötigen.

[.Hinweis]##

Note: Wenn Sie dieses Lernprogramm und die Voraussetzungen befolgt haben, haben Sie keinen Kubernetes-Namespace mit dem Namencert-manager erstellt, sodass Sie den Befehl in diesem Notizblock nicht ausführen müssen. Wenn dieser Namespace jedoch in Ihrem Cluster vorhanden ist, müssen Sie Cert-Manager benachrichtigen, damit er nicht mit dem folgenden Befehl überprüft wird:

kubectl label namespace cert-manager certmanager.k8s.io/disable-validation="true"

The Webhook component of Cert-Manager erfordert TLS-Zertifikate, um sicher mit dem Kubernetes-API-Server zu kommunizieren. Damit der Cert-Manager zum ersten Mal Zertifikate für ihn generiert, muss die Ressourcenüberprüfung für den Namespace deaktiviert werden, in dem er bereitgestellt wird. Andernfalls würde es in einer Endlosschleife stecken bleiben. Die API konnte nicht kontaktiert und die TLS-Zertifikate nicht generiert werden.

Die Ausgabe wird sein:

Outputnamespace/cert-manager labeled

Als Nächstes müssen Sie dieJetstack Helm repository zu Helm hinzufügen, auf dem sich das Cert-Manager-Diagramm befindet. Führen Sie dazu den folgenden Befehl aus:

helm repo add jetstack https://charts.jetstack.io

Helm zeigt die folgende Ausgabe an:

Output"jetstack" has been added to your repositories

Installieren Sie abschließend Cert-Manager im Namespace voncert-manager:

helm install --name cert-manager --namespace cert-manager jetstack/cert-manager

Sie werden die folgende Ausgabe sehen:

OutputNAME:   cert-manager
LAST DEPLOYED: ...
NAMESPACE: cert-manager
STATUS: DEPLOYED

RESOURCES:
==> v1/ClusterRole
NAME                                    AGE
cert-manager-edit                       3s
cert-manager-view                       3s
cert-manager-webhook:webhook-requester  3s

==> v1/Pod(related)
NAME                                     READY  STATUS             RESTARTS  AGE
cert-manager-5d669ffbd8-rb6tr            0/1    ContainerCreating  0         2s
cert-manager-cainjector-79b7fc64f-gqbtz  0/1    ContainerCreating  0         2s
cert-manager-webhook-6484955794-v56lx    0/1    ContainerCreating  0         2s

...

NOTES:
cert-manager has been deployed successfully!

In order to begin issuing certificates, you will need to set up a ClusterIssuer
or Issuer resource (for example, by creating a 'letsencrypt-staging' issuer).

More information on the different types of issuers and how to configure them
can be found in our documentation:

https://docs.cert-manager.io/en/latest/reference/issuers.html

For information on how to configure cert-manager to automatically provision
Certificates for Ingress resources, take a look at the `ingress-shim`
documentation:

https://docs.cert-manager.io/en/latest/reference/ingress-shim.html

Die Ausgabe zeigt, dass die Installation erfolgreich war. Wie inNOTES in der Ausgabe aufgeführt, müssen Sie einen Aussteller einrichten, um TLS-Zertifikate auszustellen.

Sie erstellen jetzt eine, die Let's Encrypt-Zertifikate ausstellt, und speichern die Konfiguration in einer Datei mit dem Namenproduction_issuer.yaml. Erstelle es und öffne es zum Bearbeiten:

nano production_issuer.yaml

Fügen Sie die folgenden Zeilen hinzu:

production_issuer.yaml

apiVersion: certmanager.k8s.io/v1alpha1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    # The ACME server URL
    server: https://acme-v02.api.letsencrypt.org/directory
    # Email address used for ACME registration
    email: your_email_address
    # Name of a secret used to store the ACME account private key
    privateKeySecretRef:
      name: letsencrypt-prod
    # Enable the HTTP-01 challenge provider
    http01: {}

Diese Konfiguration definiert einen ClusterIssuer, der Let’s Encrypt kontaktiert, um Zertifikate auszustellen. Sie müssenyour_email_address durch Ihre E-Mail-Adresse ersetzen, um mögliche dringende Benachrichtigungen bezüglich der Sicherheit und des Ablaufs Ihrer Zertifikate zu erhalten.

Speichern und schließen Sie die Datei.

Rollen Sie es mitkubectl aus:

kubectl create -f production_issuer.yaml

Sie werden die folgende Ausgabe sehen:

Outputclusterissuer.certmanager.k8s.io/letsencrypt-prod created

Wenn Cert-Manager installiert ist, können Sie die Zertifikate der im vorherigen Schritt definierten Ingress-Ressource hinzufügen. Öffnen Siehello-kubernetes-ingress.yaml zum Bearbeiten:

nano hello-kubernetes-ingress.yaml

Fügen Sie die markierten Zeilen hinzu:

hello-kubernetes-ingress.yaml

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: hello-kubernetes-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
    certmanager.k8s.io/cluster-issuer: letsencrypt-prod
spec:
  tls:
  - hosts:
    - hw1.example.com
    - hw2.example.com
    secretName: letsencrypt-prod
  rules:
  - host: hw1.example.com
    http:
      paths:
      - backend:
          serviceName: hello-kubernetes-first
          servicePort: 80
  - host: hw2.example.com
    http:
      paths:
      - backend:
          serviceName: hello-kubernetes-second
          servicePort: 80

Der Blocktls unterspec definiert, in welchem Geheimnis die Zertifikate für Ihre Sites (aufgeführt unterhosts) ihre Zertifikate speichern, die der ClusterIssuer vonletsencrypt-prodausgibt. Dies muss für jeden von Ihnen erstellten Ingress unterschiedlich sein.

Denken Sie daran, diehw1.example.com undhw2.example.com durch Ihre eigenen Domains zu ersetzen. Speichern und schließen Sie die Datei, wenn Sie mit der Bearbeitung fertig sind.

Wenden Sie diese Konfiguration erneut auf Ihren Cluster an, indem Sie den folgenden Befehl ausführen:

kubectl apply -f hello-kubernetes-ingress.yaml

Sie werden die folgende Ausgabe sehen:

Outputingress.extensions/hello-kubernetes-ingress configured

Sie müssen einige Minuten warten, bis die Let's Encrypt-Server ein Zertifikat für Ihre Domains ausgestellt haben. In der Zwischenzeit können Sie den Fortschritt verfolgen, indem Sie die Ausgabe des folgenden Befehls überprüfen:

kubectl describe certificate letsencrypt-prod

Das Ende der Ausgabe sieht ungefähr so aus:

OutputEvents:
  Type    Reason              Age   From          Message
  ----    ------              ----  ----          -------
  Normal  Generated           56s   cert-manager  Generated new private key
  Normal  GenerateSelfSigned  56s   cert-manager  Generated temporary self signed certificate
  Normal  OrderCreated        56s   cert-manager  Created Order resource "hello-kubernetes-1197334873"
  Normal  OrderComplete       31s   cert-manager  Order "hello-kubernetes-1197334873" completed successfully
  Normal  CertIssued          31s   cert-manager  Certificate issued successfully

Wenn Ihre letzte AusgabezeileCertificate issued successfully lautet, können Sie den Vorgang beenden, indem SieCTRL + C drücken. Navigieren Sie in Ihrem Browser zu einer Ihrer Domänen, um sie zu testen. Das Vorhängeschloss links neben der Adressleiste Ihres Browsers zeigt an, dass Ihre Verbindung sicher ist.

In diesem Schritt haben Sie Cert-Manager mithilfe von Helm installiert und einen Let's Encrypt ClusterIssuer erstellt. Anschließend haben Sie Ihre Ingress-Ressource aktualisiert, um die Vorteile des Ausstellers für das Generieren von TLS-Zertifikaten zu nutzen. Am Ende haben Sie bestätigt, dass HTTPS ordnungsgemäß funktioniert, indem Sie in Ihrem Browser zu einer Ihrer Domänen navigieren.

Fazit

Sie haben den Nginx Ingress Controller und Cert-Manager jetzt erfolgreich mit Helm auf Ihrem DigitalOcean Kubernetes-Cluster eingerichtet. Sie können Ihre Apps jetzt in Ihren Domains für das Internet verfügbar machen und mit Let's Encrypt TLS-Zertifikaten sichern.

Weitere Informationen zum Helm-Paketmanager finden Sie inintroduction article.

TOC

Einrichten eines Nginx Ingress auf DigitalOcean-Kubernetes mit Helm

Einführung

Voraussetzungen

Fazit

Related