Von Google verwaltete SSL-Zertifikate verwenden

Auf dieser Seite wird gezeigt, wie Sie mit Ingress-Objekten externe Load-Balancer mit von Google verwalteten SSL-Zertifikaten erstellen können. Diese Zertifikate sind DV-Zertifikate (Domain Validation), die von Google für Ihre Domainnamen bereitgestellt, verlängert und verwaltet werden. Diese Zertifikate veranschaulichen nicht Ihre natürliche oder geschäftliche Identität. Wie Sie von Google verwaltete Zertifikate erstellen, erfahren Sie unter Von Google verwaltete Zertifikate.

API-Versionen

Von Google verwaltete SSL-Zertifikate konfigurieren Sie mithilfe einer benutzerdefinierten Ressource ManagedCertificate, die je nach Ihrer GKE-Clusterversion in verschiedenen API-Versionen verfügbar ist:

ManagedCertificate v1beta2 API ist in GKE-Clusterversionen ab Version 1.15 und höher verfügbar.
ManagedCertificate v1 API ist in den GKE-Clusterversionen 1.17.9-gke.6300 und höher verfügbar.

GKE-Cluster unterstützen derzeit die ManagedCertificate v1beta1 API. Diese API-Version ist aber veraltet und wird in zukünftigen GKE-Versionen entfernt. Es wird empfohlen, eine neuere API-Version zu verwenden.

Migration zwischen API-Versionen

ManagedCertificate-Ressourcen werden automatisch zu einer neueren API-Version hochgestuft, wenn sie in einem Cluster aktualisiert werden, der die neuere API-Version unterstützt. Die Ressourcen werden regelmäßig aktualisiert, sodass Sie keine Maßnahmen für das Migrieren der Ressourcen ergreifen müssen.

Ingress mit von Google verwaltetem Zertifikat erstellen

So konfigurieren Sie ein von Google verwaltetes SSL-Zertifikat und verknüpfen es mit einem Ingress:

Erstellen Sie ein ManagedCertificate-Objekt.
Verknüpfen Sie das ManagedCertificate-Objekt mit einem Ingress. Dazu fügen Sie dem Ingress die Annotation networking.gke.io/managed-certificates hinzu. Die Annotation besteht aus einer durch Kommas getrennten Liste von ManagedCertificate-Ressourcen, z. B. cert1,cert2,cert3.

Beschränkungen

Von Google verwaltete Zertifikate bieten nicht das gleiche Maß an Flexibilität wie die von Ihnen abgerufenen und verwalteten Zertifikate. Von Google verwaltete Zertifikate unterstützen bis zu 100 Domains ohne Platzhalter; selbstverwaltete Zertifikate können Platzhalter unterstützen.

Wenn Sie selbstverwaltete Zertifikate benötigen oder bereits SSL-Zertifikate haben, die Sie für den Ingress konfigurieren möchten, lesen Sie die Dokumentation zu Ingress.

Die Anzahl und der Typ der von einem Ingress unterstützten Zertifikate richten sich nach den Limits der in Google Cloud verwalteten SSL-Zertifikate.

Aktualisierungen für von Google verwaltete Zertifikate werden nicht unterstützt.

Für eine manuelle Änderung mit minimalen Ausfallzeiten führen Sie die Schritte unter Von Google verwaltetes Zertifikat manuell aktualisieren aus.

Vorbereitung

Sie müssen Inhaber des Domainnamens sein. Der Domainname darf maximal 63 Zeichen haben. Sie können Google Domains oder einen anderen Registrator verwenden.
"kubernetes.io/ingress.class" muss "gce" lauten.
Erstellen Sie eine reservierte (statische) externe IP-Adresse. Wenn Sie eine statische IP-Adresse reservieren, bleibt diese auch nach dem Löschen des Ingress-Objekts erhalten. Wenn Sie keine IP-Adresse reservieren, kann sich die verwendete Adresse ändern, sodass Sie die DNS-Einträge Ihrer Domain neu konfigurieren müssen. Verwenden Sie das gcloud-Befehlszeilentool oder die Cloud Console, um eine reservierte IP-Adresse zu erstellen.
gcloud
Führen Sie den folgenden Befehl aus, um eine reservierte IP-Adresse zu erstellen:
```
gcloud compute addresses create address-name --global
```
Dabei ist address-name der Name der reservierten IP-Adresse, die Sie anlegen.

Führen Sie den folgenden Befehl aus, um die erstellte statische IP-Adresse zu ermitteln:
```
gcloud compute addresses describe address-name --global
```
Die Ausgabe sieht etwa so aus:
```
address: 203.0.113.32
...
```
Console
1. Rufen Sie in der Cloud Console die Seite "Statische Adresse reservieren" auf.
  Zur Seite "Statische IP-Adresse reservieren"
2. Geben Sie einen Namen für diese IP-Adresse an (z. B. example-ip-address).
3. Legen Sie fest, ob es sich um eine IPv4- oder IPv6-Adresse handelt. Im folgenden Beispiel wird eine IPv4-Adresse verwendet.
4. Wählen Sie als Adresstyp "Global" aus.
5. Klicken Sie auf Reservieren, um die IP-Adresse zu reservieren.
6. Die IP-Adresse wird in der Spalte Externe Adresse aufgeführt.
Config Connector
Hinweis: Für diesen Schritt ist Config Connector erforderlich. Folgen Sie der Installationsanleitung, um Config Connector in Ihrem Cluster zu installieren.

Auf GitHub ansehen
```
apiVersion: compute.cnrm.cloud.google.com/v1beta1
kind: ComputeAddress
metadata:
  name: example-ip-address
spec:
  location: global
```
Laden Sie dieses Manifest zur Bereitstellung als Datei compute-address.yaml auf Ihren Computer herunter und führen Sie folgenden Befehl aus:
```
kubectl apply -f compute-address.yaml
```

Von Google verwaltetes Zertifikat einrichten

Erstellen Sie eine ManagedCertificate-Ressource. Diese Ressource gibt die Domains an, für die das SSL-Zertifikat erstellt wird. Domains mit Platzhaltern werden nicht unterstützt.

Hier ist ein Beispiel für ein ManagedCertificate-Manifest:

Hinweis: Verwenden Sie die ältere v1beta2 API-Version, wenn Sie einen Cluster ausführen, bei dem ManagedCertificate v1 API nicht verfügbar ist.
```
apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: certificate-name
spec:
  domains:
    - domain-name1
    - domain-name2
```
wobei
- certificate-name ist der Name Ihrer ManagedCertificate-Ressource.
- domain-name1 und domain-name2 sind Ihre Domainnamen, z. B. example.com, mail.example.com und www.example.com.
Speichern Sie das Manifest als Datei mit dem Namen certificate-name.yaml und erstellen Sie dann die Ressource mit dem folgenden Befehl:
```
kubectl apply -f certificate-name.yaml
```
Hinweis: Damit diese ManagedCertificate-Ressource Active wird, muss sie zuerst an eine Ingress-Ressource angehängt werden (siehe Schritt 3). Das ManagedCertificate muss also nicht bereits für Sie Active sein, damit es an ein Ingress-Objekt angehängt werden kann.
Erstellen Sie einen NodePort-Dienst, um die Anwendung im Internet bereitzustellen.

Hier ist ein Beispiel für eine Service-Manifestdatei:
```
apiVersion: v1
kind: Service
metadata:
  name: service-name
spec:
  selector:
    key: value
  type: NodePort
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
```
In dieser Beispielspezifikation werden Pods ausgewählt, die mit dem selector in den Service aufgenommen werden sollen. Weitere Details zum Konfigurieren des Service finden Sie in der Dokumentation zu NodePort.

Speichern Sie das Manifest als Datei mit dem Namen service-name.yaml und erstellen Sie den Service dann mit dem folgenden Befehl:
```
kubectl apply -f service-name.yaml
```
Erstellen Sie einen Ingress und verknüpfen Sie ihn mit dem zuvor erstellten verwalteten Zertifikat.

Hier sehen Sie ein Beispiel für ein Ingress-Manifest:
```
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: ingress-name
  annotations:
    kubernetes.io/ingress.global-static-ip-name: address-name
    networking.gke.io/managed-certificates: certificate-name
    kubernetes.io/ingress.class: "gce"
spec:
  backend:
    serviceName: service-name
    servicePort: service-port
```
Dabei gilt:
- ingress-name ist der Name Ihres Ingress-Objekts.
- address-name ist der Name Ihrer reservierten IP-Adresse.
- certificate-name ist der Name Ihres Zertifikats.
- service-name ist der Name des Service, den Sie im vorherigen Schritt erstellt haben.
- service-port ist der Port, den Sie im Service-Manifest angegeben haben. Beachten Sie, dass dies der Wert des Felds port sein sollte und nicht des Felds targetPort.
Speichern Sie das Manifest als Datei mit dem Namen ingress-name.yaml und erstellen Sie dann das Ingress-Objekt mit dem folgenden Befehl:
```
kubectl apply -f ingress-name.yaml
```
Hinweis: Es kann 10 bis 20 Minuten dauern, bis der Load-Balancer funktioniert.
Suchen Sie die im vorherigen Schritt erstellte IP-Adresse des Load-Balancers. Rufen Sie die IP-Adresse des Load-Balancers mit dem folgenden Befehl ab:
```
kubectl get ingress
```
Die Ausgabe sieht etwa so aus:
```
NAME              HOSTS     ADDRESS         PORTS     AGE
example-ingress   *         203.0.113.32     80        54s
```
Die IP-Adresse des Load-Balancers wird in der Spalte ADDRESS aufgeführt. Wenn Sie eine reservierte statische IP-Adresse verwenden, gilt diese für den Load-Balancer.

Wenn die Adresse nicht aufgeführt wird, warten Sie, bis der Ingress fertig eingerichtet ist.
Konfigurieren Sie die DNS-Einträge für Ihre Domains so, dass sie auf die IP-Adresse des Load-Balancers verweisen. Wenn Sie Cloud DNS verwenden, finden Sie weitere Informationen in der Dokumentation Einträge verwalten.
Hinweis: Warten Sie, bis die konfigurierten DNS-Einträge verteilt wurden. Anschließend können Sie fortfahren.
Warten Sie, bis das von Google verwaltete Zertifikat bereitgestellt wurde. Dies kann bis zu 60 Minuten dauern. Den Status des Zertifikats können Sie mit dem folgenden Befehl überprüfen:
```
kubectl describe managedcertificate certificate-name
```
Wenn ein Zertifikat erfolgreich bereitgestellt wurde, ändert sich der Wert des Feldes Status.CertificateStatus in Active. Das folgende Beispiel zeigt die Ausgabe von kubectl describe, nachdem das Zertifikat erfolgreich bereitgestellt wurde:
```
Name:         certificate-name
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         ManagedCertificate
(...)
Spec:
  Domains:
    domain-name1
    domain-name2
Status:
  CertificateStatus: Active
(...)
```
Prüfen Sie, ob die SSL-Verbindung funktioniert. Rufen Sie hierfür Ihre Domains mit dem Präfix https:// auf. Ob die Verbindung sicher ist, sehen Sie im Browser. Hier können Sie auch die Zertifikatdetails aufrufen.

Von selbstverwalteten Zertifikaten zu von Google verwalteten Zertifikaten migrieren

Wenn Sie einen Ingress von selbstverwalteten Zertifikaten zu von Google verwalteten SSL-Zertifikaten migrieren, löschen Sie die selbstverwalteten SSL-Zertifikate erst, wenn die von Google verwalteten SSL-Zertifikate aktiv sind. Die Aktivierung der von Google verwalteten SSL-Zertifikate erfolgt automatisch nach der Bereitstellung. Sobald die von Google verwalteten SSL-Zertifikate aktiv sind, können Sie Ihre selbstverwalteten SSL-Zertifikate löschen.

Führen Sie die folgenden Schritte aus, um von selbstverwalteten Zertifikaten zu von Google verwalteten Zertifikaten zu migrieren.

Fügen Sie dem Ingress gemäß der Beschreibung unter Von Google verwaltetes Zertifikat einrichten ein neues von Google verwaltetes Zertifikat hinzu.
Warten Sie, bis sich der Status der von Google verwalteten Zertifikatressource in "Active" (Aktiv) ändert. Prüfen Sie den Status des Zertifikats mit dem folgenden Befehl:
```
kubectl describe managedcertificate certificate-name
```
Wenn der Status "Active" (Aktiv) lautet, aktualisieren Sie den Ingress, um die Verweise auf das selbstverwaltete Zertifikat zu entfernen.

Von Google verwaltetes Zertifikat entfernen

Wenn Sie ein von Google verwaltetes Zertifikat aus dem Cluster entfernen möchten, löschen Sie die ManagedCertificate-Ressource und entfernen Sie die darauf verweisende Ingress-Annotation.

Löschen Sie die ManagedCertificate-Ressource mit kubectl:

kubectl delete -f certificate-name.yaml

Daraufhin wird Folgendes ausgegeben:

managedcertificate.networking.gke.io "certificate-name" deleted

Entfernen Sie die Annotation aus dem Ingress:
```
kubectl annotate ingress ingress-name networking.gke.io/managed-certificates-
```
Am Ende des Befehls wird ein Minuszeichen ("–") angezeigt.
Geben Sie die statische IP-Adresse frei, die Sie für den Load-Balancer reserviert hatten:
gcloud
gcloud-Befehlszeilentool verwenden:
```
gcloud compute addresses delete address-name --global
```
Dabei ist address-name der Name der IP-Adresse.
Console
1. Rufen Sie in der Cloud Console die Seite "Externe IP-Adressen" auf.
  Zur Seite "Externe IP-Adressen"
2. Klicken Sie auf das Kästchen neben der IP-Adresse, die Sie freigeben möchten.
3. Klicken Sie auf IP-Adresse freigeben.
Config Connector
Hinweis: Für diesen Schritt ist Config Connector erforderlich. Folgen Sie der Installationsanleitung, um Config Connector in Ihrem Cluster zu installieren.

Auf GitHub ansehen
```
apiVersion: compute.cnrm.cloud.google.com/v1beta1
kind: ComputeAddress
metadata:
  name: example-ip-address
spec:
  location: global
```
Laden Sie dieses Manifest zur Bereitstellung als Datei compute-address.yaml auf Ihren Computer herunter und führen Sie folgenden Befehl aus:
```
kubectl delete -f compute-address.yaml
```

Fehlerbehebung

Dieser Abschnitt enthält Informationen zum Beheben von Problemen mit von Google verwalteten Zertifikaten.

Ereignisse zu ManagedCertificate- und Ingress-Ressourcen prüfen

Wenn Sie die zulässige Anzahl an Zertifikaten überschreiten, wird ManagedCertificate v1 ein Ereignis mit dem Grund TooManyCertificates hinzugefügt. Sie können die Ereignisse in einem ManagedCertificate-Objekt mit dem folgenden Befehl prüfen:

kubectl describe managedcertificate certificate-name

wobei

certificate-name ist der Name des ManagedCertificate-Objekts.

Wenn Sie ein nicht vorhandenes ManagedCertificate v1 an eine Ingress-Ressource anhängen, wird der Ingress-Ressource ein Ereignis mit dem Grund MissingCertificate hinzugefügt. Sie können die Ereignisse für eine Ingress-Ressource mit dem folgenden Befehl prüfen:

kubectl describe ingress ingress-name

wobei

ingress-name ist der Name Ihres Ingress-Objekts.

Verwaltetes Zertifikat wird nicht bereitgestellt, wenn die Domain in IP-Adressen mehrerer Load-Balancer aufgelöst wird

Wenn Ihre Domain in IP-Adressen von mehreren Load-Balancern (mehreren Ingress-Objekten) aufgelöst wird, sollten Sie eine einzige ManagedCertificate-Ressource erstellen und an alle Ingress-Objekte anhängen. Wenn Sie stattdessen viele ManagedCertificate-Ressourcen erstellen und jede an ein separates Ingress-Objekt anhängen, kann die Zertifizierungsstelle möglicherweise nicht die Inhaberschaft Ihrer Domain bestätigen und einige Ihrer Zertifikate werden gegebenenfalls nicht bereitgestellt. Damit die Bestätigung erfolgreich ist, muss das Zertifikat unter allen IP-Adressen sichtbar sein, in die Ihre Domain aufgelöst wird.

Wenn Ihre Domain in eine IPv4- und eine IPv6-Adresse aufgelöst wird, die mit verschiedenen Ingress-Ressourcen konfiguriert ist, sollten Sie eine einzige ManagedCertificate-Ressource erstellen und an beide Ingress-Objekte anhängen.

Unterbrechung der Kommunikation zwischen von Google verwalteten Zertifikaten und Ingress

Verwaltete Zertifikate kommunizieren über die kubernetes.io/pre-shared-cert-Annotation mit dem Ingress-Objekt. Diese Kommunikation kann beispielsweise in folgenden Fällen unterbrochen werden:

Sie führen einen automatisierten Prozess aus, der die kubernetes.io/pre-shared-cert-Annotation immer wieder löscht.
Sie speichern einen Ingress-Snapshot, löschen den Ingress und stellen ihn aus dem Snapshot wieder her. In der Zwischenzeit wurde möglicherweise eine SslCertificate-Ressource gelöscht, die in der pre-shared-cert-Annotation des Ingress-Objekts aufgeführt ist. Ingress hat eine "Alles oder nichts"-Semantik und funktioniert nicht, wenn ein zugehöriges Zertifikat fehlt.

Wenn die Kommunikation zwischen von Google verwalteten Zertifikaten und Ingress unterbrochen wird, löschen Sie den Inhalt der Annotation kubernetes.io/pre-shared-cert und warten Sie, bis sich das System abgeglichen hat. Achten Sie darauf, dass die Annotation nicht versehentlich geändert oder gelöscht wird, um eine Wiederholung zu verhindern.

Validierungsfehler beim Erstellen eines von Google verwalteten Zertifikats

ManagedCertificate-Definitionen werden vor dem Erstellen der ManagedCertificate-Ressource überprüft. Wenn die Überprüfung fehlschlägt, wird keine ManagedCertificate-Ressource erstellt. Sie erhalten stattdessen eine Fehlermeldung. Die verschiedenen Fehlermeldungen und Ursachen werden im Folgenden erläutert:

`spec.domains in body should have at most 100 items`

Ihr ManagedCertificate-Manifest enthält mehr als 100 Domains im Feld spec.domains. Von Google verwaltete Zertifikate unterstützen nur bis zu 100 Domains.

`spec.domains in body should match '^(([a-zA-Z0-9]+|[a-zA-Z0-9][-a-zA-Z0-9][a-zA-Z0-9])\.)+[a-zA-Z][-a-zA-Z0-9][a-zA-Z0-9]\.?$'`

Sie haben im Feld spec.domains einen ungültigen Domainnamen oder einen Domainnamen mit einem Platzhalter angegeben. Die ManagedCertificate-Ressource unterstützt keine Domains mit Platzhaltern (z. B. *.example.com).

`spec.domains in body should be at most 63 chars long`

Der angegebene Domainname ist zu lang. Von Google verwaltete Zertifikate unterstützen nur Domainnamen mit maximal 63 Zeichen.

Von Google verwaltetes Zertifikat manuell aktualisieren

Um das Zertifikat manuell zu aktualisieren, führen Sie die im Folgenden aufgeführten Schritte aus. Damit ist gewährleistet, dass das Zertifikat für die alte Domain weiterhin funktioniert, bis das Zertifikat für die neue Domain bereitgestellt wird.

Erstellen Sie ein neues von Google verwaltetes Zertifikat für die neue Domain.
Hängen Sie es an das Ingress-Objekt an, ohne das alte Zertifikat zu entfernen.
Warten Sie, bis der Status AKTIV wird.
Trennen Sie das alte Zertifikat vom Ingress-Objekt und löschen Sie es.