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 individuelle oder geschäftliche Identität.

Informationen zum Erstellen von von Google verwalteten Zertifikaten mit Google Cloud finden Sie unter Von Google verwaltete Zertifikate.

Von Google verwaltete SSL-Zertifikate unterstützen öffentliche und private Cluster.

API-Versionen

Sie konfigurieren von Google verwaltete SSL-Zertifikate mit einer benutzerdefinierten Ressource vom Typ ManagedCertificate, die in verschiedenen API-Versionen verfügbar ist, je nach Ihrer GKE-Clusterversion (Google Kubernetes Engine):

Die ManagedCertificate v1beta2 API ist in GKE-Versionen ab 1.15 verfügbar.
Die ManagedCertificate v1 API ist in GKE-Versionen ab 1.17.9-gke.6300 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-Objekte 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 im selben Namespace wie dem des Ingress-Objekts.
Verknüpfen Sie das ManagedCertificate-Objekt mit einem Ingress. Dazu fügen Sie dem Ingress die Annotation networking.gke.io/managed-certificates hinzu. Diese Annotation ist eine durch Kommas getrennte Liste von ManagedCertificate-Objekten.

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. Im Gegensatz zu selbstverwalteten Zertifikaten unterstützen von Google verwaltete Zertifikate keine Domains mit Platzhaltern.

Wenn Sie selbstverwaltete Zertifikate benötigen oder bereits SSL-Zertifikate haben, die Sie für das Ingress konfigurieren möchten, finden Sie entsprechende Informationen unter HTTPS (TLS) zwischen Client und Load-Balancer einrichten.

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

Aktualisierungen für von Google verwaltete Zertifikate werden nicht unterstützt. Weitere Informationen finden Sie unter Von Google verwaltetes Zertifikat manuell aktualisieren.

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.
Für den Cluster muss das Add-on HttpLoadBalancing aktiviert sein.
"kubernetes.io/ingress.class" muss "gce" lauten.
Sie müssen Ressourcen vom Typ Ingress und ManagedCertificate im selben Projekt und im selben Namespace anwenden.
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 die Google Cloud CLI 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
```
Ersetzen Sie ADDRESS_NAME durch den Namen der reservierten IP-Adresse, die Sie erstellen.

Führen Sie den folgenden Befehl aus, um die erstellte statische IP-Adresse zu finden:
```
gcloud compute addresses describe ADDRESS_NAME --global
```
Die entsprechende Ausgabe sieht etwa so aus:
```
address: 203.0.113.32
...
```
Console
Führen Sie die folgenden Schritte aus, um eine reservierte IP-Adresse zu erstellen:
1. Rufen Sie in der Cloud Console die Seite Externe IP-Adressen auf.
  
  Zu externen IP-Adressen
2. Geben Sie einen Namen für die IP-Adresse an (z. B. example-ip-address).
3. Geben Sie an, ob Sie eine IPv4- oder IPv6-Adresse möchten.
4. Wählen Sie für Typ die Option Global aus.
5. Klicken Sie auf Reservieren. 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 als 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 ein ManagedCertificate-Objekt. Diese Ressource gibt die Domains für das SSL-Zertifikat an. Domains mit Platzhaltern werden nicht unterstützt.

Das folgende Manifest beschreibt ein ManagedCertificate-Objekt. Speichern Sie das Manifest als managed-cert.yaml.

Hinweis: Wenn Sie einen Cluster ausführen, in dem die ManagedCertificate v1 API nicht verfügbar ist, verwenden Sie die ältere v1beta2 API-Version.
```
apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: managed-cert
spec:
  domains:
    - DOMAIN_NAME1
    - DOMAIN_NAME2
```
Dabei gilt:
- DOMAIN_NAME1 und DOMAIN_NAME2 sind Ihre Domainnamen. Beispiele: example.com und www.example.com.
Wenden Sie das Manifest auf Ihren Cluster an:
```
kubectl apply -f managed-cert.yaml
```
Erstellen Sie einen Service vom Typ NodePort, um Ihre Anwendung im Internet freizugeben.

Das folgende Manifest beschreibt einen Service vom Typ NodePort. Speichern Sie das Manifest als mc-service.yaml.
```
apiVersion: v1
kind: Service
metadata:
  name: mc-service
spec:
  selector:
    app: mc-service
  type: NodePort
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
```
Wenden Sie das Manifest auf Ihren Cluster an:
```
kubectl apply -f mc-service.yaml
```
Hinweis: Damit dieses ManagedCertificate-Objekt Active wird, müssen Sie es an ein Ingress anhängen. Das ManagedCertificate muss nicht bereits Active sein, damit Sie ihn an ein Ingress anhängen können.

Erstellen Sie eine Ingress-Ressource.

Das folgende Manifest beschreibt ein Ingress, das das von Ihnen erstellte ManagedCertificate verwendet. Speichern Sie das Manifest als managed-cert-ingress.yaml.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: managed-cert-ingress
  annotations:
    kubernetes.io/ingress.global-static-ip-name: ADDRESS_NAME
    networking.gke.io/managed-certificates: managed-cert
    kubernetes.io/ingress.class: "gce"
spec:
  defaultBackend:
    service:
      name: mc-service
      port:
        number: SERVICE_PORT

Dabei gilt:

ADDRESS_NAME ist der Name Ihrer reservierten IP-Adresse.
SERVICE_PORT ist der Wert von ports.port in Ihrem Dienstmanifest.

Wenden Sie das Manifest auf Ihren Cluster an:
```
kubectl apply -f managed-cert-ingress.yaml
```
Hinweis: Es kann bis zu 20 Minuten dauern, bis Google Cloud den Load-Balancer bereitstellt.
Rufen Sie die IP-Adresse des Load-Balancers ab:
```
kubectl get ingress
```
Die entsprechende 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 unter Einträge verwalten.
Hinweis: Warten Sie, bis die konfigurierten DNS-Einträge verteilt wurden. Anschließend können Sie fortfahren.
Warten Sie, bis die Bereitstellung des von Google verwalteten Zertifikats abgeschlossen ist. Dies kann bis zu 60 Minuten dauern. Sie können den Status des Zertifikats mit dem folgenden Befehl prüfen:
```
kubectl describe managedcertificate managed-cert
```
Die entsprechende Ausgabe sieht etwa so aus:
```
Name:         managed-cert
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         ManagedCertificate
(...)
Spec:
 Domains:
   DOMAIN_NAME1
   DOMAIN_NAME2
Status:
 CertificateStatus: Active
(...)
```
Der Wert des Felds Status.CertificateStatus gibt an, dass das Zertifikat bereitgestellt wird. Wenn Status.CertificateStatus nicht Active ist, wurde das Zertifikat noch nicht bereitgestellt.
Prüfen Sie, ob die SSL-Verbindung funktioniert. Rufen Sie hierfür Ihre Domains mit dem Präfix https:// auf. Ihr Browser gibt an, dass die Verbindung sicher ist und Sie die Zertifikatdetails aufrufen können.

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 managed-cert
```
Wenn der Status Active 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 das ManagedCertificate-Objekt und entfernen Sie die darauf verweisende Ingress-Annotation.

Löschen Sie das ManagedCertificate-Objekt:

kubectl delete -f managed-cert.yaml

Die entsprechende Ausgabe sieht etwa so aus:

managedcertificate.networking.gke.io "managed-cert" deleted

Entfernen Sie die Annotation aus dem Ingress:
```
kubectl annotate ingress managed-cert-ingress networking.gke.io/managed-certificates-
```
Achten Sie auf das Minuszeichen - am Ende des Befehls.
Geben Sie die statische IP-Adresse frei, die Sie für den Load-Balancer reserviert hatten.

Sie können die Google Cloud CLI, die Cloud Console oder Config Connector verwenden, um eine reservierte IP-Adresse freizugeben.
gcloud
Verwenden Sie den folgenden Befehl, um die reservierte IP-Adresse freizugeben:
```
gcloud compute addresses delete ADDRESS_NAME --global
```
Ersetzen Sie ADDRESS_NAME durch den Namen der IP-Adresse.
Console
Führen Sie die folgenden Schritte aus, um die reservierte IP-Adresse freizugeben:
1. Rufen Sie in der Cloud Console die Seite Externe IP-Adressen auf.
  
  Zu externen IP-Adressen
2. Aktivieren Sie 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 als 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 Anzahl der zulässigen Zertifikate überschreiten, wird ein Ereignis mit dem Grund TooManyCertificates zum ManagedCertificate hinzugefügt. Mit dem folgenden Befehl können Sie die Ereignisse für ein ManagedCertificate-Objekt prüfen:

kubectl describe managedcertificate CERTIFICATE_NAME

Ersetzen Sie CERTIFICATE_NAME durch den Namen Ihres ManagedCertificate.

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

Ersetzen Sie INGRESS_NAME durch Ihren Ingress-Namen.

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

Wenn Ihre Domain in IP-Adressen mehrerer Load-Balancer (mehrere Ingress-Objekte) aufgelöst wird, sollten Sie ein einzelnes ManagedCertificate-Objekt erstellen und an alle Ingress-Objekte anhängen. Wenn Sie stattdessen viele ManagedCertificate-Objekte erstellen und jedes dieser Objekte an ein separates Ingress-Objekt anhängen, kann die Zertifizierungsstelle möglicherweise nicht die Inhaberschaft Ihrer Domain bestätigen und einige Ihrer Zertifikate werden möglicherweise 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-Objekten konfiguriert ist, sollten Sie ein einziges ManagedCertificate-Objekt 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 in folgenden Fällen unterbrochen werden:

Sie führen einen automatisierten Prozess aus, der die Annotation kubernetes.io/pre-shared-cert löscht.
Speichern Sie einen Ingress-Snapshot und löschen Sie ihn dann aus dem Snapshot und stellen Sie ihn wieder her. In der Zwischenzeit wurde möglicherweise eine SslCertificate-Ressource gelöscht, die in der pre-shared-cert-Annotation aufgeführt ist. Ingress 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 des ManagedCertificate-Objekts validiert. Wenn die Validierung fehlschlägt, wird das ManagedCertificate-Objekt nicht erstellt und eine Fehlermeldung wird ausgegeben. 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. Das ManagedCertificate-Objekt 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 ManagedCertificate für die neue Domain.
Fügen Sie den Namen des ManagedCertificate der Annotation networking.gke.io/managed-certificates im Ingress mithilfe einer durch Kommas getrennten Liste hinzu. Entfernen Sie nicht den alten Zertifikatsnamen.
Warten Sie, bis das ManagedCertificate aktiv wird.
Trennen Sie das alte Zertifikat vom Ingress-Objekt und löschen Sie es.

Wenn Sie ein ManagedCertificate erstellen, erstellt Google Cloud ein von Google verwaltetes SSL-Zertifikat. Sie können dieses Zertifikat nicht aktualisieren. Wenn Sie das ManagedCertificate aktualisieren, löscht Google Cloud das von Google verwaltete SSL-Zertifikat und erstellt es neu.