Jak vygenerovat certifikát s vlastním podpisem pro Kubernetes

Úvod

V roce 2020 změnil Google Chrome chování SameSite=None soubory cookie vyžadují aktivaci Secure volba. Výsledkem je, že testování klienta webového uživatelského rozhraní, jehož backend API běží v místním clusteru Kubernetes, nyní vyžaduje přístup HTTPS.

V tomto kurzu se dozvíte, jak získat přístup HTTPS vygenerováním certifikátu podepsaného svým držitelem pro Kubernetes pomocí metod cert-manager, CFSSL, Easy-RSA a OpenSSL.

Předpoklady

• Cluster Kubernetes (můžete jej vytvořit pomocí minikube)
• nainstalován nástroj příkazového řádku kubectl

Generování certifikátů prostřednictvím správce certifikátů

Jako nativní řadič správy certifikátů Kubernetes, správce certifikátů doplněk je nejběžnějším způsobem generování certifikátů s vlastním podpisem.

Krok 1:Nainstalujte správce certifikátů

Chcete-li nainstalovat cert-manager, nejprve pro něj vytvořte jmenný prostor:

kubectl create namespace cert-manager

Dále použijte kubectl apply a yaml soubor dostupný online pro instalaci doplňku:

kubectl apply --validate=false -f https://github.com/jetstack/cert-manager/releases/download/v0.13.1/cert-manager.yaml

Krok 2:Vytvořte vydavatele certifikátu

Vytvořte jmenný prostor kde budete generovat certifikáty:

kubectl create namespace [namespace]

Dále definujte vydavatele certifikátu zadáním následujícího víceřádkového příkazu do terminálu:

kubectl apply -n [namespace] -f <(echo "
apiVersion: cert-manager.io/v1alpha2
kind: Issuer
metadata:
  name: [issuer-name]
spec:
  selfSigned: {}
")

Výstup potvrzuje úspěšné vytvoření vydavatele:

Takto vytvořený vydavatel funguje pouze pro aktuální jmenný prostor. Pokud chcete mít možnost požadovat certifikáty z libovolného jmenného prostoru v clusteru, vytvořte vlastní zdroj Kubernetes s názvem ClusterIssuer pomocí dostupného selfsigned-issuer.yaml soubor:

kubectl apply -f https://gist.githubusercontent.com/t83714/51440e2ed212991655959f45d8d037cc/raw/7b16949f95e2dd61e522e247749d77bc697fd63c/selfsigned-issuer.yaml

Krok 3:Vygenerujte certifikát

Vygenerujte certifikát s vlastním podpisem zadáním následujícího víceřádkového příkazu do terminálu:

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]
')

Výstup potvrzuje, že vytvoření bylo úspěšné:

Chcete-li zkontrolovat certifikát, který jste vytvořili, zadejte:

kubectl -n [namespace] get certificate

Chcete-li zobrazit informace o tajemství, použijte get secret příkaz:

kubectl -n [namespace] get secret [secret-name]

Tři klíče obsažené v tomto tajném klíči jsou ca.crt , tls.crt a tls.key . Pro celé tajemství zadejte:

kubectl -n [namespace] get secret [secret-name] -o yaml

Krok 4:Otestujte certifikát

Pomocí následujícího příkazu otestujte platnost certifikátu:

openssl x509 -in <(kubectl -n [namespace] get secret \
  first-tls -o jsonpath='{.data.tls\.crt}' | base64 -d) \
  -text -noout

X509v3 Subject Alternative Name řádek by měl obsahovat dnsNames které jste poskytli během generování certifikátu.

Generování certifikátů prostřednictvím CFSSL

Dalším běžným nástrojem pro generování a ověřování certifikátů s vlastním podpisem je CFSSL . Nástroj se skládá ze čtyř programů:

• cfssl – nástroj příkazového řádku pro správu balíčků CFSSL.
• multirootca – server certifikační autority.
• mkbundle – tvůrce svazků certifikátů.
• cfssljson – generátor certifikátů, který používá json výstupy z cfssl a multirootca .

Níže uvedené kroky ukazují, jak vygenerovat certifikát s vlastním podpisem pomocí CFSSL.

Krok 1:Nainstalujte CFSSL pomocí Go

Chcete-li nainstalovat CFSSL, musíte nejprve nainstalovat potřebné jazykové balíčky Go. Zadejte následující příkaz:

sudo apt install golang

Poté pomocí syntaxe Go stáhněte cfssl :

go get -u github.com/cloudflare/cfssl/cmd/cfssl

Dále zkopírujte soubor z ~/go/bin do příslušné složky:

sudo cp ~/go/bin/cfssl /usr/local/bin/cfssl

Nakonec proces zopakujte s cfssljson :

go get -u github.com/cloudflare/cfssl/cmd/cfssljson
sudo cp ~/go/bin/cfssljson /usr/local/bin/cfssljson

Krok 2:Vytvořte certifikační autoritu

Po instalaci programů pokračujte vytvořením certifikační autority s vlastním podpisem (CA). Níže uvedený příklad vytvoří soubor s názvem ca.json .

Soubor definuje následující:

• CN – Obecný název orgánu
• algo – algoritmus použitý pro certifikáty
• size – velikost algoritmu v bitech
• C – Země
• L – Lokalita (město)
• ST – Stát nebo provincie
• O – Organizace
• OU – Organizační jednotka

Níže uvedený příklad je pro organizaci s názvem „Example Company“ a její organizační jednotku „Example Company Root CA“ se sídlem v New Yorku, NY, Spojené státy americké.

{
  "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"
  }
 ]
}

Vytvořte a uložte json soubor v textovém editoru. Poté jej použijte ke generování ca.pem a ca-key.pem soubory zadáním následujícího cfssl příkaz:

cfssl gencert -initca ca.json | cfssljson -bare ca

Krok 3:Vytvořte konfigurační soubor

Chcete-li pokračovat, vytvořte cfssl.json konfigurační soubor. Soubor obsahuje podrobnosti o datu vypršení platnosti certifikátu a použití pro samostatné profily (rovný, server a klient).

cfssl.json by měl vypadat takto:

{
  "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"
      }
    }
  }
}

Uložit soubor a ukončete.

Krok 4:Vytvořte zprostředkující certifikační autoritu

Další json soubor, který musíte vytvořit, je intermediate-ca.json . Definuje zprostředkující certifikační autoritu a vypadá podobně jako dříve vytvořený 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"
  }
}

Krok 5:Podepište certifikát

Po vytvoření obou souborů zadejte následující příkaz k vytvoření intermediate_ca.pem , intermediate_ca.csr a intermediate_ca-key.pem soubory a podepište zprostředkujícího CA:

cfssl gencert -initca intermediate-ca.json | cfssljson -bare intermediate_ca

Poté podepište certifikát pomocí CA a konfiguračního souboru 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

Krok 6:Vygenerujte certifikáty hostitele

Chcete-li vygenerovat certifikáty hostitele pro profily peer, server a klient, vytvořte host1.json soubor s nezbytnými informacemi o hostitelích.

{
  "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"
  ]
}

Nyní vygenerujte certifikáty pomocí konfiguračního souboru, který jste vytvořili. Pro partnerský certifikát, který umožňuje komunikaci mezi servery, zadejte:

cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=peer host1.json | cfssljson -bare host-1-peer

Chcete-li vygenerovat certifikát serveru, zadejte:

cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=server host1.json | cfssljson -bare host-1-server

Syntaxe klientského certifikátu, který není často vyžadován, ale je podporován některými systémy, je:

cfssl gencert -ca intermediate_ca.pem -ca-key intermediate_ca-key.pem -config cfssl.json -profile=client host1.json | cfssljson -bare host-1-client

Příslušné výstupy potvrzují úspěšné vygenerování certifikátů.

Generování certifikátů prostřednictvím Easy-RSA

Easy-RSA je populární nástroj pro vytváření kořenových certifikačních autorit, vyžádání a podepisování certifikátů.

Krok 1:Instalace Easy-RSA

Ke stažení balíčků Easy-RSA potřebujete curl. Pokud nemáte nainstalovaný curl, nainstalujte jej zadáním:

sudo apt install curl

Nyní zadejte následující příkaz curl:

Curl -LO https://storage.googleapis.com/kubernetes-release/easy-rsa/easy-rsa.tar.gz

Rozbalte stažený archiv:

tar xzf easy-rsa.tar.gz

Přejděte na easy-rsa-3.0.1/easyrsa3 adresář:

cd easy-rsa-master/easyrsa3

Jakmile jste ve složce, zadejte následující příkaz pro dokončení nastavení Easy-RSA:

./easyrsa init-pki

Krok 2:Vytvořte CA s vlastním podpisem

Chcete-li zahájit vytvoření CA s vlastním podpisem, použijte tento příkaz:

./easyrsa build-ca

Systém vás požádá o zadání přístupové fráze PEM pro šifrování ca.key soubor. Dále výzva vyžaduje zadání informací o CA, kterou vytváříte.

Krok 3:Vygenerujte certifikát serveru a klíč

Dalším krokem je vygenerování certifikátu serveru a klíče pomocí víceřádkového příkazu zobrazeného níže. --subject-alt-name volba nastavuje IP adresy a názvy DNS pro přístup k serveru API.

--days volba řídí délku platnosti certifikátu.

cluster.local je výchozí název domény DNS.

./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

Systém vás požádá o zopakování přístupové fráze, kterou jste vytvořili v předchozím kroku. Poté výstup potvrdí, že databáze byla aktualizována novým záznamem. Zkopírujte pki/ca.crt , pki/issued/server.crt a pki/private/server.key soubory do vašeho adresáře.

Generování certifikátů prostřednictvím OpenSSL

OpenSSL umožňuje generovat certifikáty TLS ručně. Následující kroky ukazují, jak používat OpenSSL ke generování klíčů a certifikátů pro váš cluster.

Krok 1:Nainstalujte OpenSSL

OpenSSL nástroj je běžně předinstalovaný v systémech Linux. Zkontrolujte, zda jej máte nainstalovaný, zadáním:

openssl version -a

Výstup vypadá takto:

Pokud se zobrazí zpráva, že ve svém systému nemáte OpenSSL, nainstalujte nástroj pomocí správce balíčků vaší distribuce.

Například:

sudo apt install openssl

Krok 2:Vygenerujte soubory certifikátu

Pomocí následujícího příkazu vytvořte 2048bitový šifrovaný klíč RSA pro podepisování certifikátu:

openssl genrsa -out ca.key 2048

Nyní použijte ca.key vygenerovat ca.crt . Použijte -days možnost nastavení délky platnosti certifikátu:

openssl req -x509 -new -nodes -key ca.key -subj "/CN=[master-ip-address]" -days [number] -out ca.crt

Pokud nedojde k žádné chybě, příkaz neprodukuje žádný výstup.

Nakonec vygenerujte server.key soubor s 2048bitovým šifrováním RSA:

openssl genrsa -out server.key 2048

Krok 3:Vytvořte konfigurační soubor certifikátu

Vytvořte csr.conf konfigurační soubor pro generování žádosti o podpis certifikátu (CSR). Vzorový soubor níže také předpokládá, že používáte cluster.local jako výchozí název domény DNS.

[ 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]_names

Ujistěte se, že jste nahradili vysvětlení v hranatých závorkách skutečnými hodnotami. Uložte soubor a použijte jej ke generování žádosti o podpis certifikátu:

openssl req -new -key server.key -out server.csr -config csr.conf

Příkaz nevytváří žádný výstup, ale vytváří server.csr soubor.

Krok 4:Vygenerujte certifikát

Použijte soubor, který jste vygenerovali v předchozím kroku, společně s ca.key a ca.crt pro vytvoření certifikátu serveru:

openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key \
-CAcreateserial -out server.crt -days 10000 \
-extensions v3_ext -extfile csr.conf

Výstup tohoto víceřádkového příkazu potvrdí vytvoření certifikátu a vypíše údaje z konfiguračního souboru:

Chcete-li zobrazit certifikát, který jste vytvořili, zadejte:

openssl x509 -noout -text -in ./server.crt