Présentation
En 2020, Google Chrome a modifié le comportement de SameSite=None cookies pour exiger l'activation du Secure option. Par conséquent, le test d'un client d'interface utilisateur Web dont le backend d'API s'exécute dans un cluster Kubernetes local nécessite désormais un accès HTTPS.
Dans ce didacticiel, vous apprendrez à obtenir un accès HTTPS en générant un certificat auto-signé pour Kubernetes à l'aide des méthodes cert-manager, CFSSL, Easy-RSA et OpenSSL.
Prérequis
- Un cluster Kubernetes (vous pouvez le créer en utilisant minikube)
- outil de ligne de commande kubectl installé
Génération de certificats via cert-manager
En tant que contrôleur natif de gestion des certificats Kubernetes, le cert-manager Le module complémentaire est le moyen le plus courant de générer des certificats auto-signés.
Étape 1 :Installez cert-manager
Pour installer cert-manager, créez d'abord un espace de noms :
kubectl create namespace cert-manager
Ensuite, utilisez le kubectl apply commande et le yaml fichier disponible en ligne pour installer le module complémentaire :
kubectl apply --validate=false -f https://github.com/jetstack/cert-manager/releases/download/v0.13.1/cert-manager.yaml
Étape 2 :Créer un émetteur de certificat
Créer un espace de noms où vous allez générer des certificats :
kubectl create namespace [namespace]
Ensuite, définissez un émetteur de certificat en tapant la commande multiligne suivante dans le terminal :
kubectl apply -n [namespace] -f <(echo "
apiVersion: cert-manager.io/v1alpha2
kind: Issuer
metadata:
name: [issuer-name]
spec:
selfSigned: {}
")La sortie confirme la création réussie de l'émetteur :
Un émetteur créé de cette manière ne fonctionne que pour l'espace de noms actuel. Si vous souhaitez pouvoir demander des certificats à partir de n'importe quel espace de noms dans un cluster, créez une ressource Kubernetes personnalisée appelée ClusterIssuer en utilisant le selfsigned-issuer.yaml disponible fichier :
kubectl apply -f https://gist.githubusercontent.com/t83714/51440e2ed212991655959f45d8d037cc/raw/7b16949f95e2dd61e522e247749d77bc697fd63c/selfsigned-issuer.yamlÉtape 3 :Générer un certificat
Générez un certificat auto-signé en saisissant la commande multiligne suivante dans le terminal :
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]
')La sortie confirme que la création a réussi :
Pour vérifier le certificat que vous avez créé, tapez :
kubectl -n [namespace] get certificate
Pour afficher des informations sur le secret, utilisez la commande get secret commande :
kubectl -n [namespace] get secret [secret-name]
Les trois clés contenues dans ce secret sont ca.crt , tls.crt , et tls.key . Pour l'intégralité du secret, saisissez :
kubectl -n [namespace] get secret [secret-name] -o yamlÉtape 4 :Tester le certificat
Utilisez la commande suivante pour tester la validité du certificat :
openssl x509 -in <(kubectl -n [namespace] get secret \
first-tls -o jsonpath='{.data.tls\.crt}' | base64 -d) \
-text -noout
Le X509v3 Subject Alternative Name la ligne doit contenir les dnsNames que vous avez fourni lors de la génération du certificat.
Génération de certificats via CFSSL
CFSSL est un autre outil courant pour générer et vérifier des certificats auto-signés. . L'outil se compose de quatre programmes :
cfssl– un utilitaire de ligne de commande pour la gestion des packages CFSSL.multirootca– un serveur d'autorité de certification.mkbundle– un constructeur de groupe de certificats.cfssljson– un générateur de certificat qui utilisejsonsorties decfssletmultirootca.
Les étapes ci-dessous montrent comment générer un certificat auto-signé à l'aide de CFSSL.
Étape 1 :Installez CFSSL à l'aide de Go
Pour installer CFSSL, vous devez d'abord installer les packages de langue Go nécessaires. Tapez la commande suivante :
sudo apt install golang
Ensuite, utilisez la syntaxe Go pour télécharger cfssl :
go get -u github.com/cloudflare/cfssl/cmd/cfssl
Ensuite, copiez le fichier depuis ~/go/bin dans le dossier approprié :
sudo cp ~/go/bin/cfssl /usr/local/bin/cfssl
Enfin, répétez le processus avec cfssljson :
go get -u github.com/cloudflare/cfssl/cmd/cfssljson
sudo cp ~/go/bin/cfssljson /usr/local/bin/cfssljsonÉtape 2 :Créer une autorité de certification
Après avoir installé les programmes, procédez à la création d'une autorité de certification (CA) auto-signée. L'exemple ci-dessous crée un fichier nommé ca.json .
Le fichier définit les éléments suivants :
CN– Nom commun de l'autoritéalgo– l'algorithme utilisé pour les certificatssize– taille de l'algorithme en bitsC– PaysL– Localité (ville)ST– État ou provinceO– OrganisationOU– Unité organisationnelle
L'exemple ci-dessous concerne l'organisation appelée "Example Company" et son unité organisationnelle "Example Company Root CA" basée à New York, NY, États-Unis.
{
"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"
}
]
}
Créez et enregistrez le json fichier dans un éditeur de texte. Ensuite, utilisez-le pour générer le ca.pem et ca-key.pem fichiers en tapant le cfssl suivant commande :
cfssl gencert -initca ca.json | cfssljson -bare ca
Étape 3 :Créer le fichier de configuration
Pour continuer, créez le cfssl.json fichier de configuration. Le fichier fournit des détails sur la date d'expiration du certificat et son utilisation pour des profils distincts (homologue, serveur et client).
cfssl.json devrait ressembler à ceci :
{
"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"
}
}
}
}
Enregistrer le fichier et quittez.
Étape 4 :Créer une autorité de certification intermédiaire
Un autre json le fichier que vous devez créer est intermediate-ca.json . Il définit l'autorité de certification intermédiaire et ressemble au ca.json créé précédemment :
{
"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"
}
}Étape 5 :Signez le certificat
Après avoir créé les deux fichiers, tapez la commande suivante pour créer le intermediate_ca.pem , intermediate_ca.csr et intermediate_ca-key.pem fichiers, et signez l'AC intermédiaire :
cfssl gencert -initca intermediate-ca.json | cfssljson -bare intermediate_ca
Ensuite, signez le certificat à l'aide de l'autorité de certification et du fichier de configuration 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
Étape 6 :Générer des certificats d'hôte
Pour générer des certificats d'hôte pour les profils d'homologue, de serveur et de client, créez le host1.json fichier avec les informations nécessaires sur les hôtes.
{
"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"
]
}
Maintenant, générez les certificats à l'aide du fichier de configuration que vous avez créé. Pour le certificat pair qui autorise la communication entre les serveurs, tapez :
cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=peer host1.json | cfssljson -bare host-1-peer
Pour générer un certificat de serveur, tapez :
cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=server host1.json | cfssljson -bare host-1-server
La syntaxe d'un certificat client, qui n'est pas souvent requise mais qui est prise en charge par certains systèmes, est :
cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=client host1.json | cfssljson -bare host-1-client
Les sorties respectives confirment la génération réussie des certificats.
Génération de certificats via Easy-RSA
Easy-RSA est un utilitaire populaire pour créer des autorités de certification racine, demander et signer des certificats.
Étape 1 :Installer Easy-RSA
Pour télécharger les packages Easy-RSA, vous avez besoin de curl. Si curl n'est pas installé, installez-le en tapant :
sudo apt install curlMaintenant, tapez la commande curl suivante :
Curl -LO https://storage.googleapis.com/kubernetes-release/easy-rsa/easy-rsa.tar.gz
Décompressez l'archive que vous avez téléchargé :
tar xzf easy-rsa.tar.gz
Accédez au easy-rsa-3.0.1/easyrsa3 répertoire :
cd easy-rsa-master/easyrsa3Une fois dans le dossier, saisissez la commande suivante pour terminer la configuration d'Easy-RSA :
./easyrsa init-pki
Étape 2 :Créer une autorité de certification auto-signée
Pour initier la création d'une autorité de certification auto-signée, utilisez cette commande :
./easyrsa build-ca
Le système vous demande de saisir une phrase de passe PEM pour chiffrer le ca.key dossier. Ensuite, l'invite vous demande de saisir des informations sur l'autorité de certification que vous créez.
Étape 3 :Générer un certificat et une clé de serveur
L'étape suivante consiste à générer un certificat de serveur et une clé à l'aide d'une commande multiligne illustrée ci-dessous. Le --subject-alt-name L'option définit les adresses IP et les noms DNS pour accéder au serveur API.
Les --days L'option contrôle la durée de validité du certificat.
cluster.local est le nom de domaine DNS par défaut.
./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
Le système vous demande de répéter la phrase de passe que vous avez créée à l'étape précédente. Ensuite, la sortie confirme que la base de données a été mise à jour avec une nouvelle entrée. Copiez le pki/ca.crt , pki/issued/server.crt et pki/private/server.key fichiers dans votre répertoire.
Génération de certificats via OpenSSL
OpenSSL vous permet de générer manuellement des certificats TLS. Les étapes suivantes montrent comment utiliser OpenSSL pour générer des clés et des certificats pour votre cluster.
Étape 1 :Installez OpenSSL
Le OpenSSL L'outil est généralement préinstallé sur les systèmes Linux. Vérifiez si vous l'avez installé en tapant :
openssl version -aLa sortie ressemble à ceci :
Si vous recevez un message indiquant que vous n'avez pas OpenSSL sur votre système, installez l'outil avec le gestionnaire de packages de votre distribution.
Par exemple :
sudo apt install opensslÉtape 2 :Générer les fichiers de certificat
Utilisez la commande suivante pour produire une clé chiffrée RSA 2048 bits pour la signature du certificat :
openssl genrsa -out ca.key 2048
Maintenant, utilisez le ca.key pour générer ca.crt . Utilisez les -days option pour définir la durée de validité du certificat :
openssl req -x509 -new -nodes -key ca.key -subj "/CN=[master-ip-address]" -days [number] -out ca.crtSi aucune erreur ne se produit, la commande ne produit aucune sortie.
Enfin, générez le server.key fichier avec cryptage RSA 2048 bits :
openssl genrsa -out server.key 2048
Étape 3 :Créer le fichier de configuration du certificat
Créez un csr.conf fichier de configuration pour générer une demande de signature de certificat (CSR). L'exemple de fichier ci-dessous suppose également que vous utilisez cluster.local comme nom de domaine DNS par défaut.
[ 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]_namesAssurez-vous de remplacer les explications entre crochets par les valeurs réelles. Enregistrez le fichier et utilisez-le pour générer une demande de signature de certificat :
openssl req -new -key server.key -out server.csr -config csr.conf
La commande ne produit aucune sortie, mais elle crée le server.csr fichier.
Étape 4 :Générer le certificat
Utilisez le fichier que vous avez généré à l'étape précédente avec ca.key et ca.crt pour créer un certificat de serveur :
openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key \
-CAcreateserial -out server.crt -days 10000 \
-extensions v3_ext -extfile csr.confLa sortie de cette commande multiligne confirme la création du certificat et répertorie les données que vous avez du fichier de configuration :
Pour afficher le certificat que vous avez créé, saisissez :
openssl x509 -noout -text -in ./server.crt