Einführung
Im Jahr 2020 hat Google Chrome das Verhalten von SameSite=None geändert Cookies, um die Aktivierung von Secure zu erfordern Möglichkeit. Daher ist zum Testen eines Web-UI-Clients, dessen API-Backend in einem lokalen Kubernetes-Cluster ausgeführt wird, jetzt HTTPS-Zugriff erforderlich.
In diesem Tutorial erfahren Sie, wie Sie HTTPS-Zugriff erhalten, indem Sie mit den Methoden cert-manager, CFSSL, Easy-RSA und OpenSSL ein selbstsigniertes Zertifikat für Kubernetes generieren.
Voraussetzungen
- Ein Kubernetes-Cluster (Sie können ihn mit Minikube erstellen)
- kubectl-Befehlszeilentool installiert
Generieren von Zertifikaten über cert-manager
Als nativer Kubernetes-Zertifikatsverwaltungscontroller ist der cert-manager Add-on ist die gebräuchlichste Methode, um selbstsignierte Zertifikate zu generieren.
Schritt 1:Cert-Manager installieren
Um cert-manager zu installieren, erstellen Sie zunächst einen Namespace dafür:
kubectl create namespace cert-manager
Verwenden Sie als Nächstes kubectl apply Befehl und yaml online verfügbare Datei zur Installation des Add-Ons:
kubectl apply --validate=false -f https://github.com/jetstack/cert-manager/releases/download/v0.13.1/cert-manager.yaml
Schritt 2:Erstellen Sie einen Zertifikataussteller
Namespace erstellen wo Sie Zertifikate generieren werden:
kubectl create namespace [namespace]
Als Nächstes definieren Sie einen Zertifikatsaussteller indem Sie den folgenden mehrzeiligen Befehl in das Terminal eingeben:
kubectl apply -n [namespace] -f <(echo "
apiVersion: cert-manager.io/v1alpha2
kind: Issuer
metadata:
name: [issuer-name]
spec:
selfSigned: {}
")Die Ausgabe bestätigt die erfolgreiche Ausstellererstellung:
Ein so erstellter Aussteller funktioniert nur für den aktuellen Namensraum. Wenn Sie Zertifikate von jedem Namespace in einem Cluster anfordern möchten, erstellen Sie eine benutzerdefinierte Kubernetes-Ressource namens ClusterIssuer unter Verwendung der verfügbaren selfsigned-issuer.yaml Datei:
kubectl apply -f https://gist.githubusercontent.com/t83714/51440e2ed212991655959f45d8d037cc/raw/7b16949f95e2dd61e522e247749d77bc697fd63c/selfsigned-issuer.yamlSchritt 3:Generieren Sie ein Zertifikat
Generieren Sie ein selbstsigniertes Zertifikat, indem Sie den folgenden mehrzeiligen Befehl in das Terminal eingeben:
kubectl apply -n [namespace]-f <(echo '
apiVersion: cert-manager.io/v1alpha2
kind: Certificate
metadata:
name: [certificate-name]
spec:
secretName: [secret-name]
dnsNames:
- "*.[namespace].svc.cluster.local"
- "*.[namespace]"
issuerRef:
name: [issuer-name]
')Die Ausgabe bestätigt, dass die Erstellung erfolgreich war:
Geben Sie Folgendes ein, um das von Ihnen erstellte Zertifikat zu überprüfen:
kubectl -n [namespace] get certificate
Um Informationen über das Geheimnis anzuzeigen, verwenden Sie get secret Befehl:
kubectl -n [namespace] get secret [secret-name]
Die drei in diesem Geheimnis enthaltenen Schlüssel sind ca.crt , tls.crt , und tls.key . Geben Sie für das gesamte Geheimnis Folgendes ein:
kubectl -n [namespace] get secret [secret-name] -o yamlSchritt 4:Testen Sie das Zertifikat
Verwenden Sie den folgenden Befehl, um die Gültigkeit des Zertifikats zu testen:
openssl x509 -in <(kubectl -n [namespace] get secret \
first-tls -o jsonpath='{.data.tls\.crt}' | base64 -d) \
-text -noout
Der X509v3 Subject Alternative Name Zeile sollte die dnsNames enthalten die Sie während der Zertifikatsgenerierung angegeben haben.
Generieren von Zertifikaten über CFSSL
Ein weiteres gängiges Tool zum Generieren und Verifizieren selbstsignierter Zertifikate ist CFSSL . Das Tool besteht aus vier Programmen:
cfssl– ein Befehlszeilendienstprogramm für die CFSSL-Paketverwaltung.multirootca– ein Zertifizierungsstellenserver.mkbundle– ein Paketersteller für Zertifikatspools.cfssljson– ein Zertifikatsgenerator, derjsonverwendet Ausgaben voncfsslundmultirootca.
Die folgenden Schritte zeigen, wie Sie ein selbstsigniertes Zertifikat mit CFSSL generieren.
Schritt 1:CFSSL mit Go installieren
Um CFSSL zu installieren, müssen Sie zunächst die erforderlichen Go-Sprachpakete installieren. Geben Sie den folgenden Befehl ein:
sudo apt install golang
Verwenden Sie dann die Go-Syntax, um cfssl herunterzuladen :
go get -u github.com/cloudflare/cfssl/cmd/cfssl
Kopieren Sie als Nächstes die Datei von ~/go/bin in den entsprechenden Ordner:
sudo cp ~/go/bin/cfssl /usr/local/bin/cfssl
Wiederholen Sie abschließend den Vorgang mit cfssljson :
go get -u github.com/cloudflare/cfssl/cmd/cfssljson
sudo cp ~/go/bin/cfssljson /usr/local/bin/cfssljsonSchritt 2:Erstellen Sie eine Zertifizierungsstelle
Fahren Sie nach der Installation der Programme mit der Erstellung einer selbstsignierten Zertifizierungsstelle (CA) fort. Das folgende Beispiel erstellt eine Datei mit dem Namen ca.json .
Die Datei definiert Folgendes:
CN– Allgemeiner Name der Behördealgo– der für die Zertifikate verwendete Algorithmussize– Algorithmusgröße in BitsC– LandL– Ort (Stadt)ST– Staat oder ProvinzO– OrganisationOU– Organisationseinheit
Das folgende Beispiel gilt für die Organisation namens „Example Company“ und ihre Organisationseinheit „Example Company Root CA“ mit Sitz in New York, NY, USA.
{
"CN": "Example Company Root CA",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "US",
"L": "New York",
"ST": "New York",
"O": "Example Company",
"OU": "Example Company Root CA"
}
]
}
Erstellen und speichern Sie den json Datei in einem Texteditor. Verwenden Sie es dann, um ca.pem zu generieren und ca-key.pem Dateien durch Eingabe des folgenden cfssl Befehl:
cfssl gencert -initca ca.json | cfssljson -bare ca
Schritt 3:Erstellen Sie die Konfigurationsdatei
Um fortzufahren, erstellen Sie cfssl.json Konfigurationsdatei. Die Datei enthält Details zum Ablaufdatum des Zertifikats und zur Verwendung für separate Profile (Peer, Server und Client).
cfssl.json sollte so aussehen:
{
"signing": {
"default": {
"expiry": "8760h"
},
"profiles": {
"intermediate_ca": {
"usages": [
"signing",
"digital signature",
"key encipherment",
"cert sign",
"crl sign",
"server auth",
"client auth"
],
"expiry": "8760h",
"ca_constraint": {
"is_ca": true,
"max_path_len": 0,
"max_path_len_zero": true
}
},
"peer": {
"usages": [
"signing",
"digital signature",
"key encipherment",
"client auth",
"server auth"
],
"expiry": "8760h"
},
"server": {
"usages": [
"signing",
"digital signing",
"key encipherment",
"server auth"
],
"expiry": "8760h"
},
"client": {
"usages": [
"signing",
"digital signature",
"key encipherment",
"client auth"
],
"expiry": "8760h"
}
}
}
}
Speichern die Datei und beenden.
Schritt 4:Erstellen Sie eine Zwischenzertifizierungsstelle
Ein weiterer json Datei, die Sie erstellen müssen, ist intermediate-ca.json . Sie definiert die Zwischenzertifizierungsstelle und ähnelt der zuvor erstellten ca.json :
{
"CN": " Example Company Intermediate CA",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "US",
"L": "New York",
"ST": "New York",
"O": "Example Company",
"OU": "Example Company Intermediate CA"
}
],
"ca": {
"expiry": "42720h"
}
}Schritt 5:Zertifikat signieren
Geben Sie nach dem Erstellen beider Dateien den folgenden Befehl ein, um intermediate_ca.pem zu erstellen , intermediate_ca.csr und intermediate_ca-key.pem Dateien und signieren Sie die Zwischenzertifizierungsstelle:
cfssl gencert -initca intermediate-ca.json | cfssljson -bare intermediate_ca
Signieren Sie dann das Zertifikat mit der CA und der Konfigurationsdatei cfssl.json:
cfssl sign -ca ca.pem -ca-key ca-key.pem -config cfssl.json -profile intermediate_ca intermediate_ca.csr | cfssljson -bare intermediate_ca
Schritt 6:Hostzertifikate generieren
Um Hostzertifikate für Peer-, Server- und Clientprofile zu generieren, erstellen Sie host1.json Datei mit den notwendigen Informationen über die Hosts.
{
"CN": "host.example-company.com",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "US",
"L": "New York",
"O": "Example Company",
"OU": "Example Company Intermediate CA",
"ST": "New York"
}
],
"hosts": [
"host1.example-company.com",
"localhost"
]
}
Generieren Sie nun die Zertifikate mit der von Ihnen erstellten Konfigurationsdatei. Geben Sie für das Peer-Zertifikat, das die Kommunikation zwischen Servern ermöglicht, Folgendes ein:
cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=peer host1.json | cfssljson -bare host-1-peer
Um ein Serverzertifikat zu generieren, geben Sie Folgendes ein:
cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=server host1.json | cfssljson -bare host-1-server
Die Syntax für ein Client-Zertifikat, das nicht oft benötigt wird, aber von einigen Systemen unterstützt wird, lautet:
cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=client host1.json | cfssljson -bare host-1-client
Die jeweiligen Ausgaben bestätigen die erfolgreiche Generierung der Zertifikate.
Generieren von Zertifikaten über Easy-RSA
Easy-RSA ist ein beliebtes Dienstprogramm zum Erstellen von Root-Zertifizierungsstellen, Anfordern und Signieren von Zertifikaten.
Schritt 1:Easy-RSA installieren
Um Easy-RSA-Pakete herunterzuladen, benötigen Sie curl. Wenn Sie curl nicht installiert haben, installieren Sie es, indem Sie Folgendes eingeben:
sudo apt install curlGeben Sie nun den folgenden Curl-Befehl ein:
Curl -LO https://storage.googleapis.com/kubernetes-release/easy-rsa/easy-rsa.tar.gz
Entpacken Sie das heruntergeladene Archiv:
tar xzf easy-rsa.tar.gz
Gehen Sie zu easy-rsa-3.0.1/easyrsa3 Verzeichnis:
cd easy-rsa-master/easyrsa3Sobald Sie sich im Ordner befinden, geben Sie den folgenden Befehl ein, um die Einrichtung von Easy-RSA abzuschließen:
./easyrsa init-pki
Schritt 2:Erstellen Sie eine selbstsignierte Zertifizierungsstelle
Um die Erstellung einer selbstsignierten Zertifizierungsstelle zu initiieren, verwenden Sie diesen Befehl:
./easyrsa build-ca
Das System fordert Sie auf, eine PEM-Passphrase zum Verschlüsseln des ca.key einzugeben Datei. Als Nächstes fordert die Eingabeaufforderung Sie auf, Informationen über die Zertifizierungsstelle einzugeben, die Sie erstellen.
Schritt 3:Serverzertifikat und Schlüssel generieren
Der nächste Schritt besteht darin, ein Serverzertifikat und einen Schlüssel mit einem mehrzeiligen Befehl zu generieren, der unten gezeigt wird. Der --subject-alt-name Option legt die IP-Adressen und DNS-Namen für den Zugriff auf den API-Server fest.
Die --days Option steuert die Gültigkeitsdauer des Zertifikats.
cluster.local ist der Standard-DNS-Domänenname.
./easyrsa --subject-alt-name="IP:[master-IP-address]," \
"IP:[master-cluster-IP-address]," \
"DNS:kubernetes," \
"DNS:kubernetes.default," \
"DNS:kubernetes.default.svc," \
"DNS:kubernetes.default.svc.cluster," \
"DNS:kubernetes.default.svc.cluster.local" \
--days=10000 \
build-server-full server nopass
Das System fordert Sie auf, die im vorherigen Schritt erstellte Passphrase zu wiederholen. Dann bestätigt die Ausgabe, dass die Datenbank mit einem neuen Eintrag aktualisiert wurde. Kopieren Sie pki/ca.crt , pki/issued/server.crt und pki/private/server.key Dateien in Ihr Verzeichnis.
Generieren von Zertifikaten über OpenSSL
Mit OpenSSL können Sie TLS-Zertifikate manuell generieren. Die folgenden Schritte zeigen, wie Sie OpenSSL verwenden, um Schlüssel und Zertifikate für Ihren Cluster zu generieren.
Schritt 1:OpenSSL installieren
Das OpenSSL Das Tool ist üblicherweise auf Linux-Systemen vorinstalliert. Überprüfen Sie, ob Sie es installiert haben, indem Sie Folgendes eingeben:
openssl version -aDie Ausgabe sieht so aus:
Wenn Sie eine Meldung erhalten, dass Sie OpenSSL nicht auf Ihrem System haben, installieren Sie das Tool mit dem Paketmanager Ihrer Distribution.
Zum Beispiel:
sudo apt install opensslSchritt 2:Generieren Sie die Zertifikatsdateien
Verwenden Sie den folgenden Befehl, um einen 2048-Bit-RSA-verschlüsselten Schlüssel zum Signieren von Zertifikaten zu erstellen:
openssl genrsa -out ca.key 2048
Verwenden Sie jetzt den ca.key um ca.crt zu generieren . Verwenden Sie die -days Option zum Festlegen der Gültigkeitsdauer des Zertifikats:
openssl req -x509 -new -nodes -key ca.key -subj "/CN=[master-ip-address]" -days [number] -out ca.crtWenn keine Fehler auftreten, erzeugt der Befehl keine Ausgabe.
Generieren Sie abschließend den server.key Datei mit 2048-Bit-RSA-Verschlüsselung:
openssl genrsa -out server.key 2048
Schritt 3:Erstellen Sie die Zertifikatkonfigurationsdatei
Erstellen Sie eine csr.conf Konfigurationsdatei zum Generieren eines Certificate Signing Request (CSR). Die folgende Beispieldatei geht außerdem davon aus, dass Sie cluster.local verwenden als Standard-DNS-Domänenname.
[ req ]
default_bits = 2048
prompt = no
default_md = sha256
req_extensions = req_ext
distinguished_name = dn
[ dn ]
C = [country]
ST = [state]
L = [city]
O = [company]
OU = [organization-unit]
CN = [common-name]
[ req_ext ]
subjectAltName = @alt_names
[ alt_names ]
DNS.1 = kubernetes
DNS.2 = kubernetes.default
DNS.3 = kubernetes.default.svc
DNS.4 = kubernetes.default.svc.cluster
DNS.5 = kubernetes.default.svc.cluster.local
IP.1 = [MASTER_IP]
IP.2 = [MASTER_CLUSTER_IP]
[ v3_ext ]
authorityKeyIdentifier=keyid,issuer:always
basicConstraints=CA:FALSE
keyUsage=keyEncipherment,dataEncipherment
extendedKeyUsage=serverAuth,clientAuth
[email protected]_namesAchten Sie darauf, die Erläuterungen in den eckigen Klammern durch die tatsächlichen Werte zu ersetzen. Speichern Sie die Datei und verwenden Sie sie, um eine Zertifikatsignieranforderung zu generieren:
openssl req -new -key server.key -out server.csr -config csr.conf
Der Befehl erzeugt keine Ausgabe, erstellt jedoch server.csr Datei.
Schritt 4:Generieren Sie das Zertifikat
Verwenden Sie die Datei, die Sie im vorherigen Schritt generiert haben, zusammen mit ca.key und ca.crt So erstellen Sie ein Serverzertifikat:
openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key \
-CAcreateserial -out server.crt -days 10000 \
-extensions v3_ext -extfile csr.confDie Ausgabe dieses mehrzeiligen Befehls bestätigt die Erstellung des Zertifikats und listet die Daten auf, die Sie aus der Konfigurationsdatei entnehmen:
Um das von Ihnen erstellte Zertifikat anzuzeigen, geben Sie Folgendes ein:
openssl x509 -noout -text -in ./server.crt