Come generare un certificato autofirmato per Kubernetes

Introduzione

Nel 2020 Google Chrome ha modificato il comportamento di SameSite=None cookie per richiedere l'attivazione del Secure opzione. Di conseguenza, il test di un client dell'interfaccia utente Web il cui backend API viene eseguito in un cluster Kubernetes locale ora richiede l'accesso HTTPS.

In questo tutorial imparerai come ottenere l'accesso HTTPS generando un certificato autofirmato per Kubernetes utilizzando i metodi cert-manager, CFSSL, Easy-RSA e OpenSSL.

Prerequisiti

• Un cluster Kubernetes (puoi crearlo utilizzando minikube)
• strumento da riga di comando kubectl installato

Generazione di certificati tramite cert-manager

In qualità di controller di gestione dei certificati Kubernetes nativo, il cert-manager il componente aggiuntivo è il modo più comune per generare certificati autofirmati.

Passaggio 1:installa cert-manager

Per installare cert-manager, crea prima uno spazio dei nomi per esso:

kubectl create namespace cert-manager

Quindi, usa il kubectl apply comando e yaml file disponibile online per installare il componente aggiuntivo:

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

Fase 2:crea un emittente di certificati

Crea uno spazio dei nomi dove genererai i certificati:

kubectl create namespace [namespace]

Successivamente, definisci un emittente di certificati digitando il seguente comando su più righe nel terminale:

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

L'output conferma la corretta creazione dell'emittente:

Un emittente creato in questo modo funziona solo per lo spazio dei nomi corrente. Se vuoi essere in grado di richiedere certificati da qualsiasi spazio dei nomi in un cluster, crea una risorsa Kubernetes personalizzata chiamata ClusterIssuer utilizzando il selfsigned-issuer.yaml disponibile file:

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

Fase 3:Genera un certificato

Genera un certificato autofirmato digitando il seguente comando su più righe nel terminale:

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

L'output conferma che la creazione è riuscita:

Per controllare il certificato che hai creato, digita:

kubectl -n [namespace] get certificate

Per visualizzare le informazioni sul segreto, usa il get secret comando:

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

Le tre chiavi contenute in questo segreto sono ca.crt , tls.crt e tls.key . Per l'intero Segreto, digita:

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

Fase 4:verifica il certificato

Utilizzare il comando seguente per verificare la validità del certificato:

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

Il X509v3 Subject Alternative Name la riga deve contenere il dnsNames che hai fornito durante la generazione del certificato.

Generazione di certificati tramite CFSSL

Un altro strumento comune per generare e verificare certificati autofirmati è CFSSL . Lo strumento è composto da quattro programmi:

• cfssl – un'utilità da riga di comando per la gestione dei pacchetti CFSSL.
• multirootca – un server dell'autorità di certificazione.
• mkbundle – un generatore di pacchetti di pool di certificati.
• cfssljson – un generatore di certificati che utilizza json output da cfssl e multirootca .

I passaggi seguenti mostrano come generare un certificato autofirmato utilizzando CFSSL.

Passaggio 1:installa CFSSL utilizzando Go

Per installare CFSSL, devi prima installare i pacchetti di lingua Go necessari. Digita il seguente comando:

sudo apt install golang

Quindi, usa la sintassi Go per scaricare cfssl :

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

Quindi, copia il file da ~/go/bin nella cartella appropriata:

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

Infine, ripeti il ​​processo con cfssljson :

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

Passaggio 2:crea un'autorità di certificazione

Dopo aver installato i programmi, procedere con la creazione di un'autorità di certificazione (CA) autofirmata. L'esempio seguente crea un file denominato ca.json .

Il file definisce quanto segue:

• CN – Nome comune dell'autorità
• algo – l'algoritmo utilizzato per i certificati
• size – dimensione dell'algoritmo in bit
• C – Paese
• L – Località (città)
• ST – Stato o provincia
• O – Organizzazione
• OU – Unità organizzativa

L'esempio seguente si riferisce all'organizzazione denominata "Example Company" e alla sua unità organizzativa "Example Company Root CA" con sede a New York, NY, Stati Uniti.

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

Crea e salva il json file in un editor di testo. Quindi, utilizzalo per generare il ca.pem e ca-key.pem file digitando il seguente cfssl comando:

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

Fase 3:crea il file di configurazione

Per procedere, crea il cfssl.json file di configurazione. Il file fornisce dettagli sulla data di scadenza del certificato e sull'utilizzo per profili separati (peer, server e client).

cfssl.json dovrebbe assomigliare a questo:

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

Salva il file ed esci.

Fase 4:crea un'autorità di certificazione intermedia

Un altro json il file che devi creare è intermediate-ca.json . Definisce l'autorità di certificazione intermedia e ha un aspetto simile al ca.json creato in precedenza :

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

Fase 5:firma il certificato

Dopo aver creato entrambi i file, digita il seguente comando per creare il intermediate_ca.pem , intermediate_ca.csr e intermediate_ca-key.pem file e firmare la CA intermedia:

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

Quindi, firma il certificato utilizzando la CA e il file di configurazione 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

Fase 6:Genera certificati host

Per generare certificati host per profili peer, server e client, crea il host1.json file con le informazioni necessarie sugli host.

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

Ora, genera i certificati utilizzando il file di configurazione che hai creato. Per il certificato peer che consente la comunicazione tra server, digitare:

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

Per generare un certificato del server, digita:

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 sintassi per un certificato client, che spesso non è richiesto ma è supportato da alcuni sistemi, è:

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

I rispettivi output confermano la corretta generazione dei certificati.

Generazione di certificati tramite Easy-RSA

Easy-RSA è un'utilità popolare per la creazione di autorità di certificazione radice, la richiesta e la firma di certificati.

Fase 1:installa Easy-RSA

Per scaricare i pacchetti Easy-RSA, è necessario curl. Se non hai installato curl, installalo digitando:

sudo apt install curl

Ora, digita il seguente comando curl:

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

Decomprimi l'archivio che hai scaricato:

tar xzf easy-rsa.tar.gz

Vai a easy-rsa-3.0.1/easyrsa3 directory:

cd easy-rsa-master/easyrsa3

Una volta che sei nella cartella, digita il seguente comando per completare la configurazione di Easy-RSA:

./easyrsa init-pki

Fase 2:crea una CA autofirmata

Per avviare la creazione di una CA autofirmata, utilizzare questo comando:

./easyrsa build-ca

Il sistema ti chiede di digitare una passphrase PEM per crittografare il ca.key file. Successivamente, il prompt richiede di inserire le informazioni sulla CA che stai creando.

Fase 3:genera il certificato e la chiave del server

Il passaggio successivo consiste nel generare un certificato e una chiave del server utilizzando un comando su più righe mostrato di seguito. Il --subject-alt-name l'opzione imposta gli indirizzi IP e i nomi DNS per l'accesso al server API.

I --days l'opzione controlla la durata della validità del certificato.

cluster.local è il nome di dominio DNS predefinito.

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

Il sistema chiede di ripetere la passphrase creata nel passaggio precedente. Quindi, l'output conferma che il database è stato aggiornato con una nuova voce. Copia il pki/ca.crt , pki/issued/server.crt e pki/private/server.key file nella tua directory.

Generazione di certificati tramite OpenSSL

OpenSSL consente di generare manualmente certificati TLS. I passaggi seguenti mostrano come utilizzare OpenSSL per generare chiavi e certificati per il tuo cluster.

Passaggio 1:installa OpenSSL

OpenSSL strumento è comunemente preinstallato sui sistemi Linux. Verifica di averlo installato digitando:

openssl version -a

L'output è simile a questo:

Se ricevi un messaggio che dice che non hai OpenSSL sul tuo sistema, installa lo strumento con il gestore di pacchetti della tua distribuzione.

Ad esempio:

sudo apt install openssl

Fase 2:genera i file del certificato

Utilizzare il comando seguente per produrre una chiave crittografata RSA a 2048 bit per la firma del certificato:

openssl genrsa -out ca.key 2048

Ora usa il ca.key per generare ca.crt . Usa i -days opzione per impostare la durata della validità del certificato:

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

Se non si verificano errori, il comando non produce alcun output.

Infine, genera il server.key file con crittografia RSA a 2048 bit:

openssl genrsa -out server.key 2048

Fase 3:crea il file di configurazione del certificato

Crea un csr.conf file di configurazione per la generazione di una richiesta di firma del certificato (CSR). Il file di esempio seguente presuppone inoltre che tu stia utilizzando cluster.local come nome di dominio DNS predefinito.

[ 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

Assicurati di sostituire le spiegazioni tra parentesi quadre con i valori effettivi. Salva il file e utilizzalo per generare una richiesta di firma del certificato:

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

Il comando non produce alcun output, ma crea il server.csr file.

Fase 4:Genera il certificato

Usa il file che hai generato nel passaggio precedente insieme a ca.key e ca.crt per creare un certificato del server:

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

L'output di questo comando multiriga conferma la creazione del certificato ed elenca i dati che hai dal file di configurazione:

Per visualizzare il certificato che hai creato, digita:

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